{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generative Adversarial Networks (GANs)\n",
    "\n",
    "So far in CS231N, all the applications of neural networks that we have explored have been **discriminative models** that take an input and are trained to produce a labeled output. This has ranged from straightforward classification of image categories to sentence generation (which was still phrased as a classification problem, our labels were in vocabulary space and we’d learned a recurrence to capture multi-word labels). In this notebook, we will expand our repetoire, and build **generative models** using neural networks. Specifically, we will learn how to build models which generate novel images that resemble a set of training images.\n",
    "\n",
    "### What is a GAN?\n",
    "\n",
    "In 2014, [Goodfellow et al.](https://arxiv.org/abs/1406.2661) presented a method for training generative models called Generative Adversarial Networks (GANs for short). In a GAN, we build two different neural networks. Our first network is a traditional classification network, called the **discriminator**. We will train the discriminator to take images, and classify them as being real (belonging to the training set) or fake (not present in the training set). Our other network, called the **generator**, will take random noise as input and transform it using a neural network to produce images. The goal of the generator is to fool the discriminator into thinking the images it produced are real.\n",
    "\n",
    "We can think of this back and forth process of the generator ($G$) trying to fool the discriminator ($D$), and the discriminator trying to correctly classify real vs. fake as a minimax game:\n",
    "$$\\underset{G}{\\text{minimize}}\\; \\underset{D}{\\text{maximize}}\\; \\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\log D(x)\\right] + \\mathbb{E}_{z \\sim p(z)}\\left[\\log \\left(1-D(G(z))\\right)\\right]$$\n",
    "where $x \\sim p_\\text{data}$ are samples from the input data, $z \\sim p(z)$ are the random noise samples, $G(z)$ are the generated images using the neural network generator $G$, and $D$ is the output of the discriminator, specifying the probability of an input being real. In [Goodfellow et al.](https://arxiv.org/abs/1406.2661), they analyze this minimax game and show how it relates to minimizing the Jensen-Shannon divergence between the training data distribution and the generated samples from $G$.\n",
    "\n",
    "To optimize this minimax game, we will aternate between taking gradient *descent* steps on the objective for $G$, and gradient *ascent* steps on the objective for $D$:\n",
    "1. update the **generator** ($G$) to minimize the probability of the __discriminator making the correct choice__. \n",
    "2. update the **discriminator** ($D$) to maximize the probability of the __discriminator making the correct choice__.\n",
    "\n",
    "While these updates are useful for analysis, they do not perform well in practice. Instead, we will use a different objective when we update the generator: maximize the probability of the **discriminator making the incorrect choice**. This small change helps to allevaiate problems with the generator gradient vanishing when the discriminator is confident. This is the standard update used in most GAN papers, and was used in the original paper from [Goodfellow et al.](https://arxiv.org/abs/1406.2661). \n",
    "\n",
    "In this assignment, we will alternate the following updates:\n",
    "1. Update the generator ($G$) to maximize the probability of the discriminator making the incorrect choice on generated data:\n",
    "$$\\underset{G}{\\text{maximize}}\\;  \\mathbb{E}_{z \\sim p(z)}\\left[\\log D(G(z))\\right]$$\n",
    "2. Update the discriminator ($D$), to maximize the probability of the discriminator making the correct choice on real and generated data:\n",
    "$$\\underset{D}{\\text{maximize}}\\; \\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\log D(x)\\right] + \\mathbb{E}_{z \\sim p(z)}\\left[\\log \\left(1-D(G(z))\\right)\\right]$$\n",
    "\n",
    "### What else is there?\n",
    "Since 2014, GANs have exploded into a huge research area, with massive [workshops](https://sites.google.com/site/nips2016adversarial/), and [hundreds of new papers](https://github.com/hindupuravinash/the-gan-zoo). Compared to other approaches for generative models, they often produce the highest quality samples but are some of the most difficult and finicky models to train (see [this github repo](https://github.com/soumith/ganhacks) that contains a set of 17 hacks that are useful for getting models working). Improving the stabiilty and robustness of GAN training is an open research question, with new papers coming out every day! For a more recent tutorial on GANs, see [here](https://arxiv.org/abs/1701.00160). There is also some even more recent exciting work that changes the objective function to Wasserstein distance and yields much more stable results across model architectures: [WGAN](https://arxiv.org/abs/1701.07875), [WGAN-GP](https://arxiv.org/abs/1704.00028).\n",
    "\n",
    "\n",
    "GANs are not the only way to train a generative model! For other approaches to generative modeling check out the [deep generative model chapter](http://www.deeplearningbook.org/contents/generative_models.html) of the Deep Learning [book](http://www.deeplearningbook.org). Another popular way of training neural networks as generative models is Variational Autoencoders (co-discovered [here](https://arxiv.org/abs/1312.6114) and [here](https://arxiv.org/abs/1401.4082)). Variational autoencoders combine neural networks with variational inference to train deep generative models. These models tend to be far more stable and easier to train but currently don't produce samples that are as pretty as GANs.\n",
    "\n",
    "Example pictures of what you should expect (yours might look slightly different):\n",
    "\n",
    "![caption](gan_outputs_tf.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# A bunch of utility functions\n",
    "\n",
    "def show_images(images):\n",
    "    images = np.reshape(images, [images.shape[0], -1])  # images reshape to (batch_size, D)\n",
    "    sqrtn = int(np.ceil(np.sqrt(images.shape[0])))\n",
    "    sqrtimg = int(np.ceil(np.sqrt(images.shape[1]))) \n",
    "\n",
    "    fig = plt.figure(figsize=(sqrtn, sqrtn))\n",
    "    gs = gridspec.GridSpec(sqrtn, sqrtn)\n",
    "    gs.update(wspace=0.05, hspace=0.05)\n",
    "\n",
    "    for i, img in enumerate(images):\n",
    "        ax = plt.subplot(gs[i])\n",
    "        plt.axis('off')\n",
    "        ax.set_xticklabels([])\n",
    "        ax.set_yticklabels([])\n",
    "        ax.set_aspect('equal')\n",
    "        plt.imshow(img.reshape([sqrtimg,sqrtimg]))\n",
    "    return\n",
    "\n",
    "def preprocess_img(x):\n",
    "    return 2 * x - 1.0\n",
    "\n",
    "def deprocess_img(x):\n",
    "    return (x + 1.0) / 2.0\n",
    "\n",
    "def rel_error(x,y):\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n",
    "\n",
    "def count_params():\n",
    "    \"\"\"Count the number of parameters in the current TensorFlow graph \"\"\"\n",
    "    param_count = np.sum([np.prod(x.get_shape().as_list()) for x in tf.global_variables()])\n",
    "    return param_count\n",
    "\n",
    "\n",
    "def get_session():\n",
    "    config = tf.ConfigProto()\n",
    "    config.gpu_options.allow_growth = True\n",
    "    session = tf.Session(config=config)\n",
    "    return session\n",
    "\n",
    "answers = np.load('gan-checks-tf.npz')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset\n",
    " GANs are notoriously finicky with hyperparameters, and also require many training epochs. In order to make this assignment approachable without a GPU, we will be working on the MNIST dataset, which is 60,000 training and 10,000 test images. Each picture contains a centered image of white digit on black background (0 through 9). This was one of the first datasets used to train convolutional neural networks and it is fairly easy -- a standard CNN model can easily exceed 99% accuracy. \n",
    " \n",
    "\n",
    "**Heads-up**: Our MNIST wrapper returns images as vectors. That is, they're size (batch, 784). If you want to treat them as images, we have to resize them to (batch,28,28) or (batch,28,28,1). They are also type np.float32 and bounded [0,1]. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MNIST(object):\n",
    "    def __init__(self, batch_size, shuffle=False):\n",
    "        \"\"\"\n",
    "        Construct an iterator object over the MNIST data\n",
    "        \n",
    "        Inputs:\n",
    "        - batch_size: Integer giving number of elements per minibatch\n",
    "        - shuffle: (optional) Boolean, whether to shuffle the data on each epoch\n",
    "        \"\"\"\n",
    "        train, _ = tf.keras.datasets.mnist.load_data()\n",
    "        X, y = train\n",
    "        X = X.astype(np.float32)/255\n",
    "        X = X.reshape((X.shape[0], -1))\n",
    "        self.X, self.y = X, y\n",
    "        self.batch_size, self.shuffle = batch_size, shuffle\n",
    "\n",
    "    def __iter__(self):\n",
    "        N, B = self.X.shape[0], self.batch_size\n",
    "        idxs = np.arange(N)\n",
    "        if self.shuffle:\n",
    "            np.random.shuffle(idxs)\n",
    "        return iter((self.X[i:i+B], self.y[i:i+B]) for i in range(0, N, B)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# show a batch\n",
    "mnist = MNIST(batch_size=16) \n",
    "show_images(mnist.X[:16])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LeakyReLU\n",
    "In the cell below, you should implement a LeakyReLU. See the [class notes](http://cs231n.github.io/neural-networks-1/) (where alpha is small number) or equation (3) in [this paper](http://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf). LeakyReLUs keep ReLU units from dying and are often used in GAN methods (as are maxout units, however those increase model size and therefore are not used in this notebook).\n",
    "\n",
    "HINT: You should be able to use `tf.maximum`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def leaky_relu(x, alpha=0.01):\n",
    "    \"\"\"Compute the leaky ReLU activation function.\n",
    "    \n",
    "    Inputs:\n",
    "    - x: TensorFlow Tensor with arbitrary shape\n",
    "    - alpha: leak parameter for leaky ReLU\n",
    "    \n",
    "    Returns:\n",
    "    TensorFlow Tensor with the same shape as x\n",
    "    \"\"\"\n",
    "    # TODO: implement leaky ReLU\n",
    "    return tf.maximum(x,alpha*x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your leaky ReLU implementation. You should get errors < 1e-10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum error: 0\n"
     ]
    }
   ],
   "source": [
    "def test_leaky_relu(x, y_true):\n",
    "    tf.reset_default_graph()\n",
    "    with get_session() as sess:\n",
    "        y_tf = leaky_relu(tf.constant(x))\n",
    "        y = sess.run(y_tf)\n",
    "        print('Maximum error: %g'%rel_error(y_true, y))\n",
    "\n",
    "test_leaky_relu(answers['lrelu_x'], answers['lrelu_y'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Noise\n",
    "Generate a TensorFlow `Tensor` containing uniform noise from -1 to 1 with shape `[batch_size, dim]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_noise(batch_size, dim):\n",
    "    \"\"\"Generate random uniform noise from -1 to 1.\n",
    "    \n",
    "    Inputs:\n",
    "    - batch_size: integer giving the batch size of noise to generate\n",
    "    - dim: integer giving the dimension of the the noise to generate\n",
    "    \n",
    "    Returns:\n",
    "    TensorFlow Tensor containing uniform noise in [-1, 1] with shape [batch_size, dim]\n",
    "    \"\"\"\n",
    "    # TODO: sample and return noise\n",
    "    return tf.random_uniform((batch_size, dim),minval=-1,maxval=1,dtype=tf.float32)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure noise is the correct shape and type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All tests passed!\n"
     ]
    }
   ],
   "source": [
    "def test_sample_noise():\n",
    "    batch_size = 3\n",
    "    dim = 4\n",
    "    tf.reset_default_graph()\n",
    "    with get_session() as sess:\n",
    "        z = sample_noise(batch_size, dim)\n",
    "        # Check z has the correct shape\n",
    "        assert z.get_shape().as_list() == [batch_size, dim]\n",
    "        # Make sure z is a Tensor and not a numpy array\n",
    "        assert isinstance(z, tf.Tensor)\n",
    "        # Check that we get different noise for different evaluations\n",
    "        z1 = sess.run(z)\n",
    "        z2 = sess.run(z)\n",
    "        assert not np.array_equal(z1, z2)\n",
    "        # Check that we get the correct range\n",
    "        assert np.all(z1 >= -1.0) and np.all(z1 <= 1.0)\n",
    "        print(\"All tests passed!\")\n",
    "    \n",
    "test_sample_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discriminator\n",
    "Our first step is to build a discriminator. You should use the layers in `tf.layers` to build the model.\n",
    "All fully connected layers should include bias terms. For initialization, just use the default initializer used by the `tf.layers` functions.\n",
    "\n",
    "Architecture:\n",
    " * Fully connected layer with input size 784 and output size 256\n",
    " * LeakyReLU with alpha 0.01\n",
    " * Fully connected layer with output size 256\n",
    " * LeakyReLU with alpha 0.01\n",
    " * Fully connected layer with output size 1 \n",
    " \n",
    "The output of the discriminator should thus have shape `[batch_size, 1]`, and contain real numbers corresponding to the scores that each of the `batch_size` inputs is a real image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discriminator(x):\n",
    "    \"\"\"Compute discriminator score for a batch of input images.\n",
    "    \n",
    "    Inputs:\n",
    "    - x: TensorFlow Tensor of flattened input images, shape [batch_size, 784]\n",
    "    \n",
    "    Returns:\n",
    "    TensorFlow Tensor with shape [batch_size, 1], containing the score \n",
    "    for an image being real for each input image.\n",
    "    \"\"\"\n",
    "    with tf.variable_scope(\"discriminator\"):\n",
    "        # TODO: implement architecture\n",
    "        x=tf.layers.dense(x,256,use_bias=True)\n",
    "        x=leaky_relu(x,alpha=0.01)\n",
    "        x=tf.layers.dense(x,256,use_bias=True)\n",
    "        x=leaky_relu(x,alpha=0.01)\n",
    "        logits=tf.layers.dense(x,1,use_bias=True)\n",
    "        return logits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test to make sure the number of parameters in the discriminator is correct:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct number of parameters in discriminator.\n"
     ]
    }
   ],
   "source": [
    "def test_discriminator(true_count=267009):\n",
    "    tf.reset_default_graph()\n",
    "    with get_session() as sess:\n",
    "        y = discriminator(tf.ones((2, 784)))\n",
    "        cur_count = count_params()\n",
    "        if cur_count != true_count:\n",
    "            print('Incorrect number of parameters in discriminator. {0} instead of {1}. Check your achitecture.'.format(cur_count,true_count))\n",
    "        else:\n",
    "            print('Correct number of parameters in discriminator.')\n",
    "        \n",
    "test_discriminator()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generator\n",
    "Now to build a generator. You should use the layers in `tf.layers` to construct the model. All fully connected layers should include bias terms. Note that you can use the tf.nn module to access activation functions. Once again, use the default initializers for parameters.\n",
    "\n",
    "Architecture:\n",
    " * Fully connected layer with inupt size tf.shape(z)[1] (the number of noise dimensions) and output size 1024\n",
    " * `ReLU`\n",
    " * Fully connected layer with output size 1024 \n",
    " * `ReLU`\n",
    " * Fully connected layer with output size 784\n",
    " * `TanH` (To restrict every element of the output to be in the range [-1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator(z):\n",
    "    \"\"\"Generate images from a random noise vector.\n",
    "    \n",
    "    Inputs:\n",
    "    - z: TensorFlow Tensor of random noise with shape [batch_size, noise_dim]\n",
    "    \n",
    "    Returns:\n",
    "    TensorFlow Tensor of generated images, with shape [batch_size, 784].\n",
    "    \"\"\"\n",
    "    with tf.variable_scope(\"generator\"):\n",
    "        # TODO: implement architecture\n",
    "        x=tf.layers.dense(z,1024,use_bias=True)\n",
    "        x=leaky_relu(x,alpha=0)\n",
    "        x=tf.layers.dense(x,1024,use_bias=True)\n",
    "        x=leaky_relu(x,alpha=0)\n",
    "        x=tf.layers.dense(x,784,use_bias=True)\n",
    "        img=tf.tanh(x)\n",
    "        return img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test to make sure the number of parameters in the generator is correct:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct number of parameters in generator.\n"
     ]
    }
   ],
   "source": [
    "def test_generator(true_count=1858320):\n",
    "    tf.reset_default_graph()\n",
    "    with get_session() as sess:\n",
    "        y = generator(tf.ones((1, 4)))\n",
    "        cur_count = count_params()\n",
    "        if cur_count != true_count:\n",
    "            print('Incorrect number of parameters in generator. {0} instead of {1}. Check your achitecture.'.format(cur_count,true_count))\n",
    "        else:\n",
    "            print('Correct number of parameters in generator.')\n",
    "        \n",
    "test_generator()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GAN Loss\n",
    "\n",
    "Compute the generator and discriminator loss. The generator loss is:\n",
    "$$\\ell_G  =  -\\mathbb{E}_{z \\sim p(z)}\\left[\\log D(G(z))\\right]$$\n",
    "and the discriminator loss is:\n",
    "$$ \\ell_D = -\\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\log D(x)\\right] - \\mathbb{E}_{z \\sim p(z)}\\left[\\log \\left(1-D(G(z))\\right)\\right]$$\n",
    "Note that these are negated from the equations presented earlier as we will be *minimizing* these losses.\n",
    "\n",
    "**HINTS**: Use [tf.ones_like](https://www.tensorflow.org/api_docs/python/tf/ones_like) and [tf.zeros_like](https://www.tensorflow.org/api_docs/python/tf/zeros_like) to generate labels for your discriminator. Use [tf.nn.sigmoid_cross_entropy_with_logits](https://www.tensorflow.org/api_docs/python/tf/nn/sigmoid_cross_entropy_with_logits) to help compute your loss function. Instead of computing the expectation, we will be averaging over elements of the minibatch, so make sure to combine the loss by averaging instead of summing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gan_loss(logits_real, logits_fake):\n",
    "    \"\"\"Compute the GAN loss.\n",
    "    \n",
    "    Inputs:\n",
    "    - logits_real: Tensor, shape [batch_size, 1], output of discriminator\n",
    "        Unnormalized score that the image is real for each real image\n",
    "    - logits_fake: Tensor, shape[batch_size, 1], output of discriminator\n",
    "        Unnormalized score that the image is real for each fake image\n",
    "    \n",
    "    Returns:\n",
    "    - D_loss: discriminator loss scalar\n",
    "    - G_loss: generator loss scalar\n",
    "    \n",
    "    HINT: for the discriminator loss, you'll want to do the averaging separately for\n",
    "    its two components, and then add them together (instead of averaging once at the very end).\n",
    "    \"\"\"\n",
    "    # TODO: compute D_loss and G_loss\n",
    "    D_loss = None\n",
    "    G_loss = None\n",
    "    G_loss=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(logits_fake),logits=logits_fake))\n",
    "    D_loss=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=\n",
    "                          tf.ones_like(logits_real),logits=logits_real))+tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=\n",
    "                          tf.zeros_like(logits_fake),logits=logits_fake))\n",
    "    return D_loss, G_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your GAN loss. Make sure both the generator and discriminator loss are correct. You should see errors less than 1e-5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum error in d_loss: 6.02597e-17\n",
      "Maximum error in g_loss: 7.19722e-17\n"
     ]
    }
   ],
   "source": [
    "def test_gan_loss(logits_real, logits_fake, d_loss_true, g_loss_true):\n",
    "    tf.reset_default_graph()\n",
    "    with get_session() as sess:\n",
    "        d_loss, g_loss = sess.run(gan_loss(tf.constant(logits_real), tf.constant(logits_fake)))\n",
    "    print(\"Maximum error in d_loss: %g\"%rel_error(d_loss_true, d_loss))\n",
    "    print(\"Maximum error in g_loss: %g\"%rel_error(g_loss_true, g_loss))\n",
    "\n",
    "test_gan_loss(answers['logits_real'], answers['logits_fake'],\n",
    "              answers['d_loss_true'], answers['g_loss_true'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimizing our loss\n",
    "Make an `AdamOptimizer` with a 1e-3 learning rate, beta1=0.5 to mininize G_loss and D_loss separately. The trick of decreasing beta was shown to be effective in helping GANs converge in the [Improved Techniques for Training GANs](https://arxiv.org/abs/1606.03498) paper. In fact, with our current hyperparameters, if you set beta1 to the Tensorflow default of 0.9, there's a good chance your discriminator loss will go to zero and the generator will fail to learn entirely. In fact, this is a common failure mode in GANs; if your D(x) learns to be too fast (e.g. loss goes near zero), your G(z) is never able to learn. Often D(x) is trained with SGD with Momentum or RMSProp instead of Adam, but here we'll use Adam for both D(x) and G(z). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: create an AdamOptimizer for D_solver and G_solver\n",
    "def get_solvers(learning_rate=1e-3, beta1=0.5):\n",
    "    \"\"\"Create solvers for GAN training.\n",
    "    \n",
    "    Inputs:\n",
    "    - learning_rate: learning rate to use for both solvers\n",
    "    - beta1: beta1 parameter for both solvers (first moment decay)\n",
    "    \n",
    "    Returns:\n",
    "    - D_solver: instance of tf.train.AdamOptimizer with correct learning_rate and beta1\n",
    "    - G_solver: instance of tf.train.AdamOptimizer with correct learning_rate and beta1\n",
    "    \"\"\"\n",
    "    D_solver = None\n",
    "    G_solver = None\n",
    "    D_solver=tf.train.AdamOptimizer(learning_rate=learning_rate,beta1=beta1,name='Adam')\n",
    "    G_solver=tf.train.AdamOptimizer(learning_rate=learning_rate,beta1=beta1,name='Adam')\n",
    "    return D_solver, G_solver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting it all together\n",
    "Now just a bit of Lego Construction.. Read this section over carefully to understand how we'll be composing the generator and discriminator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "# number of images for each batch\n",
    "batch_size = 128\n",
    "# our noise dimension\n",
    "noise_dim = 96\n",
    "\n",
    "# placeholder for images from the training dataset\n",
    "x = tf.placeholder(tf.float32, [None, 784])\n",
    "# random noise fed into our generator\n",
    "z = sample_noise(batch_size, noise_dim)\n",
    "# generated images\n",
    "G_sample = generator(z)\n",
    "\n",
    "with tf.variable_scope(\"\") as scope:\n",
    "    #scale images to be -1 to 1\n",
    "    logits_real = discriminator(preprocess_img(x))\n",
    "    # Re-use discriminator weights on new inputs\n",
    "    scope.reuse_variables()\n",
    "    logits_fake = discriminator(G_sample)\n",
    "\n",
    "# Get the list of variables for the discriminator and generator\n",
    "D_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'discriminator')\n",
    "G_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'generator') \n",
    "\n",
    "# get our solver\n",
    "D_solver, G_solver = get_solvers()\n",
    "\n",
    "# get our loss\n",
    "D_loss, G_loss = gan_loss(logits_real, logits_fake)\n",
    "\n",
    "# setup training steps\n",
    "D_train_step = D_solver.minimize(D_loss, var_list=D_vars)\n",
    "G_train_step = G_solver.minimize(G_loss, var_list=G_vars)\n",
    "D_extra_step = tf.get_collection(tf.GraphKeys.UPDATE_OPS, 'discriminator')\n",
    "G_extra_step = tf.get_collection(tf.GraphKeys.UPDATE_OPS, 'generator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training a GAN!\n",
    "Well that wasn't so hard, was it? After the first epoch, you should see fuzzy outlines, clear shapes as you approach epoch 3, and decent shapes, about half of which will be sharp and clearly recognizable as we pass epoch 5. In our case, we'll simply train D(x) and G(z) with one batch each every iteration. However, papers often experiment with different schedules of training D(x) and G(z), sometimes doing one for more steps than the other, or even training each one until the loss gets \"good enough\" and then switching to training the other. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a giant helper function\n",
    "def run_a_gan(sess, G_train_step, G_loss, D_train_step, D_loss, G_extra_step, D_extra_step,\\\n",
    "              show_every=2, print_every=1, batch_size=128, num_epoch=10):\n",
    "    \"\"\"Train a GAN for a certain number of epochs.\n",
    "    \n",
    "    Inputs:\n",
    "    - sess: A tf.Session that we want to use to run our data\n",
    "    - G_train_step: A training step for the Generator\n",
    "    - G_loss: Generator loss\n",
    "    - D_train_step: A training step for the Generator\n",
    "    - D_loss: Discriminator loss\n",
    "    - G_extra_step: A collection of tf.GraphKeys.UPDATE_OPS for generator\n",
    "    - D_extra_step: A collection of tf.GraphKeys.UPDATE_OPS for discriminator\n",
    "    Returns:\n",
    "        Nothing\n",
    "    \"\"\"\n",
    "    # compute the number of iterations we need\n",
    "    mnist = MNIST(batch_size=batch_size, shuffle=True)\n",
    "    for epoch in range(num_epoch):\n",
    "        # every show often, show a sample result\n",
    "        if epoch % show_every == 0:\n",
    "            samples = sess.run(G_sample)\n",
    "            fig = show_images(samples[:16])\n",
    "            plt.show()\n",
    "            print()\n",
    "        for (minibatch, minbatch_y) in mnist:\n",
    "            # run a batch of data through the network\n",
    "            _, D_loss_curr = sess.run([D_train_step, D_loss], feed_dict={x: minibatch})\n",
    "            _, G_loss_curr = sess.run([G_train_step, G_loss])\n",
    "\n",
    "        # print loss every so often.\n",
    "        # We want to make sure D_loss doesn't go to 0\n",
    "        if epoch % print_every == 0:\n",
    "            print('Epoch: {}, D: {:.4}, G:{:.4}'.format(epoch,D_loss_curr,G_loss_curr))\n",
    "    print('Final images')\n",
    "    samples = sess.run(G_sample)\n",
    "\n",
    "    fig = show_images(samples[:16])\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train your GAN! This should take about 10 minutes on a CPU, or less than a minute on GPU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 0, D: 1.116, G:1.167\n",
      "Epoch: 1, D: 2.333, G:1.382\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 2, D: 1.466, G:0.6855\n",
      "Epoch: 3, D: 1.315, G:1.014\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 4, D: 1.153, G:0.9795\n",
      "Epoch: 5, D: 1.454, G:0.8976\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 6, D: 1.314, G:0.9333\n",
      "Epoch: 7, D: 1.294, G:0.7971\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 8, D: 1.361, G:0.8285\n",
      "Epoch: 9, D: 1.281, G:0.8421\n",
      "Final images\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with get_session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    run_a_gan(sess,G_train_step,G_loss,D_train_step,D_loss,G_extra_step,D_extra_step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Least Squares GAN\n",
    "We'll now look at [Least Squares GAN](https://arxiv.org/abs/1611.04076), a newer, more stable alternative to the original GAN loss function. For this part, all we have to do is change the loss function and retrain the model. We'll implement equation (9) in the paper, with the generator loss:\n",
    "$$\\ell_G  =  \\frac{1}{2}\\mathbb{E}_{z \\sim p(z)}\\left[\\left(D(G(z))-1\\right)^2\\right]$$\n",
    "and the discriminator loss:\n",
    "$$ \\ell_D = \\frac{1}{2}\\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\left(D(x)-1\\right)^2\\right] + \\frac{1}{2}\\mathbb{E}_{z \\sim p(z)}\\left[ \\left(D(G(z))\\right)^2\\right]$$\n",
    "\n",
    "\n",
    "**HINTS**: Instead of computing the expectation, we will be averaging over elements of the minibatch, so make sure to combine the loss by averaging instead of summing. When plugging in for $D(x)$ and $D(G(z))$ use the direct output from the discriminator (`score_real` and `score_fake`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lsgan_loss(scores_real, scores_fake):\n",
    "    \"\"\"Compute the Least Squares GAN loss.\n",
    "    \n",
    "    Inputs:\n",
    "    - scores_real: Tensor, shape [batch_size, 1], output of discriminator\n",
    "        The score for each real image\n",
    "    - scores_fake: Tensor, shape[batch_size, 1], output of discriminator\n",
    "        The score for each fake image    \n",
    "          \n",
    "    Returns:\n",
    "    - D_loss: discriminator loss scalar\n",
    "    - G_loss: generator loss scalar\n",
    "    \"\"\"\n",
    "    # TODO: compute D_loss and G_loss\n",
    "    D_loss = None\n",
    "    G_loss = None\n",
    "    G_loss=0.5*tf.reduce_mean((scores_fake-1)**2)\n",
    "    D_loss=0.5*tf.reduce_mean(scores_fake**2)+0.5*tf.reduce_mean((scores_real-1)**2)\n",
    "    return D_loss, G_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test your LSGAN loss. You should see errors less than 1e-7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum error in d_loss: 0\n",
      "Maximum error in g_loss: 0\n"
     ]
    }
   ],
   "source": [
    "def test_lsgan_loss(score_real, score_fake, d_loss_true, g_loss_true):\n",
    "    with get_session() as sess:\n",
    "        d_loss, g_loss = sess.run(\n",
    "            lsgan_loss(tf.constant(score_real), tf.constant(score_fake)))\n",
    "    print(\"Maximum error in d_loss: %g\"%rel_error(d_loss_true, d_loss))\n",
    "    print(\"Maximum error in g_loss: %g\"%rel_error(g_loss_true, g_loss))\n",
    "\n",
    "test_lsgan_loss(answers['logits_real'], answers['logits_fake'],\n",
    "                answers['d_loss_lsgan_true'], answers['g_loss_lsgan_true'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create new training steps so we instead minimize the LSGAN loss:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "D_loss, G_loss = lsgan_loss(logits_real, logits_fake)\n",
    "D_train_step = D_solver.minimize(D_loss, var_list=D_vars)\n",
    "G_train_step = G_solver.minimize(G_loss, var_list=G_vars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Run the following cell to train your model!_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 0, D: 0.1103, G:0.4688\n",
      "Epoch: 1, D: 0.1693, G:0.2945\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 2, D: 0.2391, G:0.07339\n",
      "Epoch: 3, D: 0.1873, G:0.2627\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 4, D: 0.2193, G:0.2064\n",
      "Epoch: 5, D: 0.2198, G:0.1937\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 6, D: 0.2181, G:0.182\n",
      "Epoch: 7, D: 0.245, G:0.1998\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 8, D: 0.1894, G:0.1834\n",
      "Epoch: 9, D: 0.2269, G:0.1874\n",
      "Final images\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPMAAADuCAYAAADsvjF6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXnYXOP5xz/vkkSajYRYomoXSm21BKFFKC1a1FZL7aoEUSVKVSy179VoSlSrqCiqlgoajS1qaxFBImqJJRHFz5ZI5vfH2+95zjxzzsw5M+fMvJm5P9flGnnnzDnP2Z77ufe2QqGAYRiLPu2NHoBhGNlgL7NhNAn2MhtGk2Avs2E0CfYyG0aTYC+zYTQJ9jIbRpNgL7NhNAn2MhtGk9CZZuO2tramCxcrFApt+v9mPz9o/nPM4vza2tq031p3lQn+PYwj1cvc7HS3m2g0hkX1/tsy2zCaBHuZQxQKhUV2VjaKaWtrC1ZaWdPR0VHzPvIYn73MhtEkmM7cQDTDL1iwoMEjaR7qcU0XLFjAcsstB8AKK6xQdNwXXngBgA8++ACA9vYuefnFF18ATh/PYwVoktkwmoRuLZkrzbInnXQSAFtuuSUAO+64Y30GVgNtbW3sueeeANx4440AdHZ23QbN3rXuH7LR6/Igb8lZj1XO+++/H5xH7969AXdeW2+9NQCPPvooAJ9//nnRb3v06AHA/PnzMx9XWxpx32gfpR76hQsXFn3qAf7HP/4BuAulC1uOrHyU/kN64IEHAnD99dcD7qauu+66TJo0CYAXX3wRgCWXXBKA1VZbLfVxtYzTtfDpLn7mnj17AvDmm28CsNRSS2W273rFChx88MEAfPLJJ1x33XWAu++33XYbAAcccAAAH330UdH3uj9633Q95s2bV/G4Sf3Mtsw2jCah2yyzkyw1e/XqBbhZTxJYSxcts//2t79lOjYdd/78+bESUBJSknn55ZcH4OOPPy7a7umnnw6kk8b75S9/GYABAwYU/XbmzJkAjBw5EoAnn3wSgIkTJwb7ixtPIzjjjDMAOOWUU4JxbbLJJgA88cQTAKy66qpAtqpFWqoNDvrZz34GQJ8+fYLxn3/++QCcfPLJgDsfHcO/P/p7EomcFpPMhtEkNFxn/vTTTwFnSGhra4udMWfPng3AOuusA8AjjzwCdBkkADbeeGMgnRGkVn3L14k0M0tSC+nMn376KV/5ylcA+Ne//lU0bknqW265BXDS6+233wbg+9//PgCDBw8G4JprrqkoXbLQmTV2HfdLX/oSAO+++y7gzlmfGnc5PvvsM8Dd91rIW2fWGMeMGQPA4YcfHlwDXZMPP/wQSL/SaG9vr7i6Mp3ZMFqMhunM0h0066288soArLXWWvz1r3+N/I2svTvssAPg9NGNNtoIaIz+uN122wFOuvoSWasEnWehUAi2WWmllYq2nTBhAuDOSwEJkr6TJ08G4L///S8Al156KaNGjSo6TpacfvrpgLMZCAVEiP79+wPOllEoFCq6oPx9dmeGDBkCOA9Fv379uOSSSwC3sqwkkeO8Dlk+syaZDaNJaJjOvPPOOwNw7bXXAl0SGZx+6B0XgM033xxw/mTNhprlqwmRi9K3JFVkZX711Vdjf6+x+UEAGtsPfvADwOnB5fah8ffr1w9weqWu0VlnnQXA1KlTY387cOBAAObOnVtyfuFzrIX9998fIPC16vpLj5w7d25ii3EWyQZ568xz5swBnI1gjTXWqGtQjunMhtFi1F1n/trXvgbAn//8Z8BJwSiJLDR7Dx8+HHD6px8qlxXS85JIZElef6bee++9gfISWfjSa7PNNgPg3nvvLTpGlBTzfyuJnCe+rq/7oM/wOOMs3HmlJ2aBv6rQv7VSUvRWLSy++OKAs39kgUlmw2gS6i6Zn3rqKcBJsqFDh1b8jSy2N998M+BmSOnQ8jdnRTl9r2/fvgD83//9HwC77bZb5D7OO+88wI05Ckkr6dua8TfYYAOAwKqvhIz99tsvxVnkh6zcSfAlsiRSd0b3/eyzzwac9HzuueeAaAu97BxCVmpFJ37yySeAi/zKUiILk8yG0STUTTIradvXLTVzhRk7dizgJLL0rpdffhlwVuY33ngjl7GWs8BKIkviKI7a56677gK6sqQAnn322WDfzzzzDOB868qaOuaYYwAn+TQO+TdFI+OakxLnX5ZE6s46s5AUVcTerbfeGnynVZRWVb/73e8AuP322wFYZZVVALjooouK9lWOWgtKmmQ2jCahbpJZ0laRM5IqkthhlO8riXXFFVcALj/Zj0DKijQST5Ln0EMPBbqyocLImn3kkUdW3NewYcMAuOOOOwA45JBDgHh7QneWyNAlYfxIOLH22mvXeTTpWWyxxQC3apSV/vnnnwfg17/+NaeddhrgbAD61OpK0XCyd+iZLSd1ay0llPvL3KdPH8A9oKJcuN+KK64IwD333AM4F81xxx0X+5ssqPSShJNA9Kkls0L+pk+fDrib66dpgjOO6IHXEk0BH/vss0+NZ9JYyl1HvRDdGS2Jdc/ee+89AEaMGAF0TdQ//OEPAfcca1upU6p+s9VWWwEwbdo0IN+a3LbMNowmIXfJrKQBuVm0zFIJFqGlTa9evXjooYcAZyxRsMjuu+8OwKmnnprzqKMpN6vOmjULcCGNQucQPj+51rR807+liuThtqgHe+yxB1CabLKooZWTApukSkl1KhQKQQirCk2oWud9990HOLVLyTPaXqtKK05gGEYsuSdayNwuN4xSxm666SbA6RQK5xw0aFAgAU855RQA/v73vwNOd5FeWg2++b8RjeOWWGIJwLmtdH5C5YJ0zWqhngX9op4lpa3Wcs8SHLfiPUzj9tHKQoZJha8qsQRcWLICSaQzS5rLeOknyVSDJVoYRouRu86smXDGjBmAm/WkBwslT3zyySdByORVV10FuLJAWY6nkchNoQJ4Pr49YVFGgT6NDhJJc9+1rYoPKoxWQUqTJ08ukciyleg5F1deeWUNo06HSWbDaBLqnmgRVyZFTvZll102+FteKY6NRtdgiy22iPxeFn9fl14UySvkNk8kmVVaV4UUFVQUPqcNN9wQcN6aO++8E4DRo0cDzjNRqVlBFphkNowmodsUwX/rrbcAePDBBwOdUmljzYbfTkeF4uWLvPzyyxszsCopp48qKWZRRF4HReYpzHjppZcObDyyWisGYs011wRcFKN063rYakwyG0aT0DDJLB1CKYWa6caOHcu4ceMaNazM8HUkSePHH388iBpaf/31i36jwnFpmoo1knKRXr6Vd1FaZSnlUemLyhFQLMSUKVOC+/mjH/0IcK2DZL3fdtttga64CXAxEnliktkwmoS6S2ZJ4F133bXo39KZr7nmmnoPqSbkE1cMuvRexVtrBg+X5FVkm9rTyGqvovfdXSKLBx98MPa7c889F4Djjz++XsOpGa0ilLWmdjS6l8qM22mnnTjhhBMA1zJJKw+1ThKVJHJHR0cQr11r72qTzIbRJNStCL4/6/hlbGUFnDdvXm75ylFkFZutwn3ySUqflERWXverr74atHN57bXXACcRFMcrn7sKyvn3KE2ccT1is6PGodWGssXyJKt7qFWVnlU1hZPXQYUGevfuHWSIKS5C9zSPjDeLzTaMFqPu7WkksVR2RZ9JqFWniKJeWVOKHrr77ruDmF9Zr9WaRxk3WZbUzVMyqzm89ELdn3Jx2PrOb04vJB3TRP/lfQ81ZuXZjxgxIqggo09VllFr1ywjvZJK5rovs+WWUVqZblojOjhC9g+Cv7xWmRylzA0aNIjrr78ecCmQJ554IkDw93POOQdw9aTK4U9w/r/zeJkruc6WX375uoZxRt3DLMMnNRGHrmnN+0yDLbMNo8Wo+zJbhgM54rUsaRRZS2a52NSv+fXXXwdcx4M5c+YEoX7aVlJcoY8yjGVBHpJZ4z3ppJMA+OUvf1nrLmuiEQUm6olJZsNoMeoumZdeemkA3nnnnVp3lQl5zepyRansrGwD//nPf4JwQb9vVVp69+4dlGGKo55lgxpF+Bzb29sL//tb4waUgvb29op6vUlmw2gx6i6ZuxtZF4NLggIpFCaY13H+t6+WkszNfn7lMMlsGE1CKslsGEb3xSSzYTQJ9jIbRpOQKp+5uxoXagndazXjSZZBI1LR6t38XSGrOv6CBQta6h7G0W0K+qVhzz33BFyLG73EeSRi5IGiwZTq2N2oZFX3/x51vTXBals/+aLSxBs1Bv2tu9/fRmHLbMNoEuruZ660JAuXUamVxRdfvGKy+KK4zE6zAolbZsdJ3z59+gQlcKr1dCy99NKJI/yyWE0tivcwDeZnNowWo1tGgClCSvHMvt4VN+ZqDGGNnNVfeuklAJZccknAFVvPMhfXn9V79OhRgPoZq/x7puID/vfKjfbPua2treIKwSRzFyaZDaNJSCWZOzs7C9A4a6IKq6vSxd133w3AlltuWfU+o2b1PGKktc9+/foFMdkqOaPj3H777UBXZhXA0UcfDbiWtpdccgngSsAmIa1rKokkrNSedcMNNwwywdQcT5VWtt9+ewCOPPJIwDXH0zH1qXs8f/78igUNGymZ/VXUdtttB8C9996b2TG6XdmgNOhmyViml1iGGb+TQi3L0UY8CKrk6BdmkDEobgms7Q877DDAuebK4T8IlVIE07zMeuFUT1rVLN9++22eeuopwE1EqpGl3yyzzDIAPPHEEwCcddZZRf/WtZg6dWpFNauRL7PGpJ5Sqn2u881C8Nky2zBajLQRYEBts3oltthii8AwdNBBBwFuKfb4448DTnKp/I7K1vzgBz+o6dh5ou4V6667bmyppEqzuK7tUUcdBSSTzHH78JfK/jI3yT5koNSKafz48QCsuuqqwapKnT5UiOGHP/whQNDpU/daJZNUCPDhhx8GuiSctm1U0cco5s6dC8CLL74IwGqrrQa4SqV6RiupJFliktkwmoRUkjlu1tYs3NbWFhh14tBMtcYaawAwa9YswM3qHR0d7LDDDgBsvvnmAOy///6AM6J885vfBGDatGmAMwilMVyV62CYByqrWw4V+ItD3TImTpxY83iyMO5JL9SKSc/BBx98EJRNGjlyJAAzZ84E4N133wVg7bXXBpxk0/OgYBOtUlZYYYVAH83DMFktciP6XT5lC9Cqsp6YZDaMJqFh4ZwXXHAB4PQ/ScpPP/00CMFUgIGspCoOL4ktPeWqq64C4NRTTy06VtpiaVmWDUoTphjX3SFuHGnIMmtKx1fnTt2H0aNHA10uKehyv33jG98AnE6s3sZ+RwtdJ6G+W3JthVdQWvX516uR1myNyS+UL6t9HoE/cZhkNowmITfJfOCBBwJwyy23AM5HKqvu0KFDATeDiX333TfofXvGGWcAzi+r3s0K/VPXxOnTpwNw/vnnJz4X0R1CAWsN0qiw70SJFuVCSP1tJZlHjBgBuLLCsmrPmzcvCOiJQ7ED/mrEH8diiy0WBNnEpbrmfQ932mknAO64446S7+ICWnR+lWxISTDJbBgtRubFCaQ7yNL5ve99D4ArrrgCcNFC8h0KSd0pU6ZwyCGHAM56O2nSJMD5NeVfVbTNEUccETmWjo6OYObsTj7KSkji6FrmgS9RyklkX1rKZyybhvz8u+++O+CiuMohP6zvVdDfde6S9mF0ffLy4cpSrdWlXxI5zK677gq4Dp5+A796YpLZMJqEzKf+Bx54AIDddtsNcFZrzbjyK2qWlw9RVs/XX3+dfffdF3CNyfRbtT5VuZ2rr74aKJUy8mF+9tlngT7tU8/IHB9dmwkTJkR+n6dETlOvK1RjC3DSRjryH/7wB8C151ViSFgy6zor9lpta9WbWlJPnzpWeHxxnoG8/M1aNeo8L7zwwthtJZF9fb4RmGQ2jCYhE2t2WKdaeeWVAbj//vsBZ82TRVoxt+uttx7g9C81lAsjn6Ok/WabbQY4S6F0aN9yuPzyywNwww03sPPOOwMueyd0Lhpz3a3Zcddc0kjnk9GxqvYz+0X5dD/0KU+E7B2jRo0CulZXa621FuCkm+wc5513HuCKGp522mkAwfZaqYXGGxw/zkKclTVbY/Kz9KJ05rh7qEZ+ukZZYNZsw2gxMlHOwpZQNReXPqXc21deeQVws+qaa64JOJ9xFJoZZSX99re/DcBdd91VtJ0/U8vfvOmmm8ZmKNU7vle6ajm/Y1KJfOihhwIwbty42gdWBj/DSvdD0lUrJmWvaZW12mqrMXbsWMDdX1mIzz777KLfqnjBjBkzyo4BSiPAsvZQJC19rNVGGNlpnn/++UzHlIaaXuaoNDr9berUqYCrb/Xkk08CsPHGGwPuJpcLldQLIKOCAhG0vNOSxg8N1As8ePDgbhGUDy7QIgq5N5KSxUsclwIZ9Td96vrKmKWXS2GcF198MdDljtQDr3vh17xWwMmjjz4KuBdTqYXaLmqyb9Q91bOsZJEwL7zwQr2HU4Itsw2jSahJMkfNkDJSKflBrgi5m/bZZ5+K+5AE2G+//QAXtnnKKacAbhmt9MkHH3wQcEEmWtINHDiQr371qwBBGRtJ83rP7gqiCSNppfRAGU10zZKg89hxxx0BKoZR+r9Lg4JEJJkGDBgAOPejpO2AAQN4+eWXAVeM4IADDgCcW04qhf6u1YZWMJLQWY09C2bPng10rSJ07/QpFUMJIo3AJLNhNAmZJloMGTIk0JWnTJkCwOqrrw64pPNNNtkk8rea1SdOnBhIXiVcSFLLmKZkjaeffhoolRgyZIwbN46f/exnQGnAQRrX1B577AHAn/70p9hzr0Q4ocFPaK9ln3G6b8gWkcg1pVXBZ599Fjs+3zaha6qkmZtvvhnouh/Dhg0DnDTTb2644QbA6dlahehTQUVJnstQAcS6uBd1Lv369QuuhZ8olAV+YI+5pgyjxchUMnd0dAS6ocL1VODsmGOOAdwMHBcAMGbMGH7+858DLrBEkkL7UlCI6kyrnrTcYTrWSSedVCKRJYFC/ZRyndWXXXZZwOn3UdJYuqeffJIFaUvtlsPXCxUIpJXRj3/8Y6DLXqJAC1mzpdNrNXXssccCcOWVVwLw6quvAu5ep3E/1SuNNWxhV5jwOuusk9fhAkwyG0aLkUnQSLg3lGZgzciSOpLEsm7KQu1z0UUXBf//zDPPAM7C+cgjjwCug4X2qUAEFcRTUYOoMjxRKXW1oBKxCpaRPq8CdUogiWLVVVcF4gMm8qCSRC5XaskvH6vrr1XYmWeeCXTdL9kt5JvVucofq5K6fvijpH53TFnVamGxxRYLvCTdCZPMhtEkZCKZw32BpLe+9tprAPz2t78FnKVTOnJcWttHH30UlCtVETiVqdW/5ZeVP3mjjTYCXNRZ1tI3ChWsU+EEJeirHLDwdaohQ4bw5ptvAgS+WF0LX2pqdSPdNAsqFScMS0Tfl6rvtFIaNGgQQFCAUfucP39+oEfrO62ydG9lAd90000BuO222xKPM4ueztUg3/f7778f2A+6EyaZDaNJyK2gn2+NlP/wV7/6FeAktqyemu2PO+64QPeSZVxxvpMnTwZceqXKukh3K9dgrEyCe4klVLq3LNFhVF5WqZySnkqfiyM8tq985SuAS/u75557yv62FnxLaM+ePQuQrtCcYgPkXVhllVUAl9Yo/+vee+8NdEWhyXqvBATdb/19q622AlxEoLwc/nMTToGMK0K4YMGCXK3ZOq8//vGPwdjqWYTArNmG0WJ0m5aukmwDBw4M+hNrJpYEU1uW3//+94CTspdeeingZuyorJY40vootYKQTihLbqWZWj7yJZdcMtM2K7Kiy6rukzQCLDwmrXRkk1ARCEXTKRJPeqNsFPJqFAqFoBiEGhiIxx57DHCZYrKDJLkWYdtM+Dd5+5n9iLiTTz6Zc889t+i7PDHJbBgtRn6V43SAhAXk5JcMJ4hr5h0+fDhAYAVWO5Q0bUizQn7R7373u0DlQm6K6pK/FbIdb5xETkqULUGST/H0Gvv6668PuJWPJLE+da/nzZsXSGTlsSsmWxFfkvaVGsyHKVfIIk9UWFI5A4svvnhuBRJqwSSzYTQJuenMms2lU1aDYqyVG/2b3/wGgIMPPhiorvWHr6+m1bf83/ux12pmF1fiN2vimqeHvk9V0C9sPfaRzrrccssBzsqrqC61Ipo+fXrgaZA0lYdAKy95ASpJuHLjEfWKzQ7f+yWWWAIoLRSZB0l15m5jAIvCN7CogqduvJaBtZDVg6C6WHqZ1cmj0cQlWujF1HI3/KD6E5afFKNQRhktVTf7xhtvDPYVl0YZ15sp5XNY9JusX+Y4N6Zcc88//3xwLerRM9oMYIbRYmQqmfv27Vtz2ZS11lorCMtUMQAVB4gLLyyHwiv//e9/F/29kXWz60mlZXaaABshQ5d6fUnFkBEriTGr3PH978sFA/3v37ncQ1UOfeihh7LaZVWYZDaMFqNb68xCM+RRRx0FwF577ZXZvqNm9TT9mLo7/qze0dFRgPKrmlr1wCTStJp9+dQrnLMc9XBRmWQ2jBajYZI5SWd5v8SPj0IrFchRDfVyazSKanTmehIn2bpj2aBGYZLZMFqMVJLZMIzui0lmw2gS7GU2jCYhVdZUsxsX0hiH/O+yMCTlYYyqpdm6Qj4bla2UFDOAdZF7CuSiTLmXKiIKKbPjxVlyVUZJRfLyptJLrMlHxRtrTccE186oXIniRYFGeAlsmW0YTcIiEQGWJ1FLNBUQ/Pjjj4u27dGjR1Vpl2lRMvw555wDuDJJanEbRZK45f9tt0jdw1mzZgUpl3HYMrsLk8yG0SSYzhyBL5GVRZSFVP7ss8+Cwninnnoq4JL9r7jiCsBJYElmld4pR5aGuDj8qD2VRFJxvr///e+AK58MsNRSSxVtq2upXPW4Znk6VjmpXGtLXLHiiisCrnndoopJZsNoEhZpyawWoiqsnxfl2qAklYTa7uWXXw5K50g3l3RStpbw93nxxRcDrsJHVO540nEkkdxqP6NyTWrqJ5eVpOt9991X9LspU6YEbWfGjx8PELTpVVM/5airfJAksCz44VVQnIssq9VHnhL50EMPBWDcuHG5HUOYAaxK44lePNU6UwmjuOupvsRLLrlk0F86LVdffTXgOmn6Lz8QdMtQ7fEsDWCq8fXEE08Arvvms88+C7i+Wp2dncFDrN8ceeSRgFMtNKmo4mdc8Ygkz+eibgDTpKna6j5mADOMFmORkMxajvrLSs3e3/zmNwFngElD2lm92mR0SaQxY8YES0gZeXzUh3qzzTYr+ruWufp85513KhZQqEYyq3CiVhvq3qFz1/j989BYOjo6AtVEVSzV8VJVOqUi3X777QBMmDABcMvSNDRCMuvZU3VW9eO66667AFeVdtiwYQCMGDECgMsvvxxIV/jCJLNhtBjdWjJrdpNO4aNuhK+88krVx8hrVtfMLQNPVD/fp556CoDLLrsMgIMOOghwHRJ1b7QKkJFI0kA9j8tRi87s1z6X/itXlOplqxdYOSoZsd544w2gupDQeknmX//610CXgW/s2LGAW7VEjKnoU6sav6f1woULK9oHTDIbRovRbSRzqDhb8De5M8aMGRP5m69//etAsqCKOPKWzJKq0pE6OzuDMkfSNSWNJAF1DWS1VpfL/v37VzyuX4wwC2u2yjMNGTIEcNJ1jTXWAFx3zmrQeNUNUokWc+fOTbyPvCXz0KFDAbcSieL0008HYOTIkYCzFSgASCG5UYEulcpfmWQ2jBajYZJZs7x0pSg0Ns1YKvAXGk/RvysVAIw5Rq4F1CdPnlzy3ZlnngmU+lz9e6GWN7LS33333anHUYtkjrPcqwPmbbfdBrgukOEwzqTMnDkTcFZuBdDssMMOifeRt2Qu947ceuutgLMjyFes36iVj9oWVVNQ3ySzYbQYdQ/nlA9V/jefxx57rOQ7JeVr1ouyDEM6iZyGuJTIKLbbbjugVIrGrS4gfuaX7/KSSy4B6pfwLj3Wb/6mf/v+8Wok8hFHHAG4Fje77LIL4Po4NxIlXmjVEEVckocSS3St5HmoR4sbk8yG0STUXTJvs802gJOiSdLY5KO88sori347YMAAwPly8yIskSvVxZLvV/qmkhQUm5wEWUCVrCAr9pprrgnA/fffn3hf1TBq1CjAJQeoLNDAgQMBF3FXixVbBRh0nWTtleVYjB8/Puj1nDdKYHnxxReL/u5HupV7ZiWRtXqaPXs2AIMHD852sBGYZDaMJqFuklmzml+ozW8fusQSSwQx2JoR/abqioTKWyJHUanInc5Tut9zzz0HlE+jFJJKkuK6NtpHVJZUHlxwwQWAkzKSWDq3WiSykD9Zzd7VelfX7Rvf+AbgUijrgc73zTffBFwT+XISWfdMKzY9m3p2N9544xxHXIxJZsNoEnL3M995552AiztWLKvybYUk3kcffcRpp50GwFVXXQWUluvJqlwMJKubLYmYpGyQcn0laTRjl2PttdcGXF6w0ApFEUJJJLMfT53Uz6w48Q022KDiMWrBj6aaPn06ACuvvDLgPBUnn3wy0BVZlSYzrBY/82OPPQY4L4JQNJq8GuF4bFnjdQ+vueaaor9nUWoqqZ+5bkEjOo5uoow5emH0Mvfs2TMytDOMDDCTJk2qdjjhcWXyIGhJHA7bhOhz0BJS45fBRWGdenmF9iF310477ZR4XHlU56ym+6YmGYVt6h7LrSUjn1IjFcIahR+kktU91JLfn4BlcA27FVUtRiqInm+lekqdTHOv4rCgEcNoMerumlLaokIaJZkl2dZYY41g1pOBS7O2Ag2ykMhRpAnK8LeVRNanjCly52ipNn369GBJKUOSQv20z8MPPxxwaoakmMIo683rr78OEJQ70lL4jjvuAOD5558HnLtp7ty5wb266aabivb1/vvvA86tOHXq1KJ9R0lkv5NHNUEqSVBii9IUVUggKtDnsMMOA1xapAJM1l13XaAxxlmTzIbRJOSuM994442AK/YmPWujjTYCYK+99gKcS2LQoEGB8UaSSq4CJWdkSRJ9S4XrRo8eHZzHjBkzisamlDdJZv3mF7/4BeAkdbkODdKNJYl9A5ikl++qA2ec0fUNBS8k0pnDRkXB4hftAAAT4klEQVR/1SEpqyIKviFOxiqdcxRxdb11rkJ2gXomWvj1wJPgGwxVsHG99dYD3Hll1IPMdGbDaCXqngJZKWnhySefDHSve++9V8et9bCxpJnVJ06cyD//+U8ADjnkEMDpfrKAanaXPik9TAUUVltttRIp5SPJKwuwttNqRlIhCWmt2eGVgz4Vzim7ho/OWdKoo6OjxKrvI8uxdGg9F0kKMPjUu6Bfe3t7sPKRi1XXStb6Wjpi+oFUJpkNo8XoNmWDxH777cd1113nHze34yWZ1SVdpk2bFkhiWTz9sWmmltVe11eSqFzgh7aV9fiBBx4AXFql9hllzY0rJFCNn1k+/7CkDSOJ4ad1qtCEAibKoTiDnXfeGYBzzz0XcMUJZMFOQiOL4Pvvj+wc8j9ndAyTzIbRSnS7XlOy/jaCOOmmNMZ33nkn8B/KfyzJrNTHo48+GnBWbknysESOs+zq35Js0rdVPkgSWd9Llw2Pudoi/eH9SNIeddRRAOy2226AS8n0OznqWFESWZJK4Y7q66TkEe1r7733BpydROd+7bXXVnUeeePr9lqtNPT5bdiRDcPIlG6jM6tnsSLDIFtfXRxJ9C1Jqs8//zwIxlcUlyR0GiStlLAuKaTmaSqtJIkn/VE6aqU0zDDV6MyKfZbPVOPx7QO6L+roqGivtra2YIyyLSi+WfdUdgAl4vilivwGeEnPsR46c7hwvY/sPQcccEBmxzOd2TBajIZLZuldiscGF9cqfTNP0s7qfpbX6NGjASepFS3lz9xKjZSvuBySxCrFe8IJJwDV6cFpJfPAgQODOHL5TFWULu5Z0blqBVOu8KEks8rpqKWrbAzyN6eJba5WMldrXygUCiV2DtkAFCGYJSaZDaPFaLhkFuFxlMsFzuG4iWf1E088MdDxpk2bBsCDDz4IuFhiSRSVXJUEKodigyUhKp2334KmHGklc0dHR0kD+SyR9Vr3W6uQJO1o/OwpUS+dWUUJPv7440Ai6x4ocyyP4g4mmQ2jxeh2krm9vT33Iu/ecaua1bfffnsA/va3v2U2lr/85S+AKwjvV1ypVOY3iloqjfi52Hkg37W8BNXQiAgwWfwlodNUXQnT2dmZqixSORr+MqvMihL058+fH1yo7rbMzoukvZpq7aUFjTvHPGnEPZThVsa+erlPy2HLbMNoEhoWzun3MVIXwLPPPrukt9SiwDLLLAM4g1eaVUXSMjiSyDLEfP7557GljvJMTqkHSdxGfuHDrNE1VZCP7u2yyy4bBMPUUyWshElmw2gS6q4za8aVc/1f//oX4CSzSuNA43Tmcq6fNAESSVl66aWByq6garpAVqMzq5b1qquumvg4lUjjTktLvXXm2bNnB67HemA6s2G0GA23Zjea8KzXs2fPArgyOGkkYZ6Sx8cvK1MOs2Y3lmrciT4mmQ2jxUglmQ3D6L6YZDaMJsFeZsNoElIFjXQ340IWRBlPkhiYlGst15SCG2QIizN49OjRo8RIpuAH/SZULxlw4Z6q8CnDXHt7e7CtP2Zts2DBgtwNYPU0/kXRiI4W9WSRic1uNFEPQpKoqriifP62SieMSoXUCxh68Yr+7cds66HTSx8VpO+PZ+HChQ2xZoej1PKmkdbsOGt1pWYPSdD9//TTT82abRgthUqgJPkPKDTbf+Hza2trK7S1tRXa29uL/tPfw7/r6OiI/E/f9+3bt9C3b99CZ2dnobOzs9CnT59Cnz59CuPHjy8MGjSoMGjQoJL96t9x//nbrb322iXb+GNOew/b29trvqb+tcp7X2mf0aj7meb7LP9Le37l/jPJbBhNgunMEfqW4self4Yzd8q0gSn6jWLPd999d8C1nHnkkUeC9p8qlKcyONK/lOgep48nyX/WvmfNmtXQCLD9998fcCVodf1+/OMfA3DFFVcAcNFFFwFw3HHHFf2+ra2tYgRerTpzNTHv9SD0/JnObBithEnm0Kzeo0ePAhDr7lliiSWCEjqbbLIJ4Aq5bbbZZgBMnToVcK1dJGl+/vOfB9urLOtdd90FwNe+9jUguWsnLElk4dZv/TFXY82uVVL17NmzxLorq7bGq2OopasytXQdlZUWVXLXXx11h9jssLsQ3PWvppxvufMrO4Z6v8x+UYKIY3DggQcCMH78+KLvsgha9wlfqM7OzrIvc/hvGot8xPJRfuc73wHgtNNOA+Db3/42QNDXefDgwSV+5LSUG5deFi3B/QfhfwauTJaUevHU8eL3v/89AAcddFBwj1555RXAuejUo8m/xj5z5swBulJkt91227LjyOplrqS+RJVtqjTx+d/7k9n8+fNTqRHlsGW2YTQJmZcNUtK2Zuu0Ce6FQoGhQ4cCrrOieh799a9/BWDWrFkAHHbYYYAr6yJpWS2aIb/1rW8BcM899wDFqwhFO/m9iSWZ1e1Q/XnVFULL7S+++CJYRkmK6ziSVrqGkk6h5VbRdmHjkLbRcjtu5ZOlkUf3eMiQIQDsu+++RZ/gOn0ILbcVVOKjczvnnHMAGD58eGBE/POf/wxU3+GyEpXKN6ki66233hr8zb+eet7VS1vPsIpvSKV64YUXgt9nZYAzyWwYTUJuOrO/X79/sJAUevLJJwHYaqutmDlzZuIxeeNLvI3GVy6cU5/h0Dz9TrHZkkpf/vKXAedykUS+8MILAXjxxReD42q/ch+pA6Z+m5SOjo6S+HFdX+mi8+bNy8015deKls4ZhdxvKtboG8Q0bq2yVMr2ueeeC9x8kvLSw0XeBjCNUZ0pZ8+ezQcffFC0jW+zUIcTdbG87777ANh6660BZ1+48sorufnmmwG3EvMxndkwWozcSu1Kh/RnXvG73/0OcF0RNetFIUuoZi7pNiuttFLRduq0+PWvfz12X0lWItpG+nG4Q6V0Yc3MmpE1Nm179NFHA6WJBj179gz0qpdeegmAY489tuKYoghLZUlFjafaDgtJUJlZXxqp/9bQoUOD89Y1XHHFFQHnapJ9Qzq+Vi5qhiAGDBgQXC91ilTyglZMeaNnWbaaKHQvdC8vueQSwK3u9NzIzqPul1/60peCFUecZE6KSWbDaBJy9zP7+/eDHHwWLlxYso1C/qRTStfMokthWB/p1atXIXzccP8rjU34up906BtvvBGAbbbZBig93wULFpTo9n4OdNw98Vc3w4cPD7pQxqUcZlnQz++dfMsttwAwatQoAF577bVgDJUK1FcTTOFfyyR2D5HyOS/6zd577w04Xf3xxx+veI/keXnggQcAOOuss4q+l41lmWWWCcpN++HDFs5pGC1KbpK5lplR2/7kJz8B4IILLii771oIz+r/S2GMLTxQKBRKrMUK21SIpqSGuhpqlpXe1a9fv0CKy/eo46gBgKz5fmigtpPOOmfOnNgqGaFCBjVLZiWG6Fzk91cklCzP8i9ff/31aQ9RE1lZsyV51WroqquuAtz1PuCAA3SM2BWF7pk+11prLcDZCNQoUVb7BQsWVKx0YtZsw2gx6habLSuvrHo+f/rTnwD4/ve/X/KdZrG439ZCeNZT3LJf00r/nj9/fjDjyuqqiJ7LLrsM6ErGAPje974HuEQCWULffffdQAJLsh188MEA3H333YCzREsiS5fWPtTO5uOPPw4soGVSMzPTmRVXLSu8xiHvgfTAv/zlL7lFaUURJZnLlS2Sd0QrCsU46Px0v4Xul/YVtjprH7IjhEr9AKWrK+1LcQhh4iLBTDIbRouRe0vXwYMHA87aK8vgH//4x6Lt3njjjZLf+jOVEthlPY3D13mTohlZY5VUVZTaW2+9FexbKXvSnTV+SWhF/Ky++uoAbLrppkCXdJVPVbO3dKZjjjkGgFNPPRUgyBbacsstATjhhBMAgjTMIUOGBP5urSKqsRLHoeux8cYbA/DQQw8B7vpefvnlgMsIk7chfGzp18OGDQPgt7/9LZB/JcxyhQQlWSVF4ySy0PnJQj9nzpzA961rofbD/nF9G8pyyy0HwE9/+lOg+Fm22GzDMIA66swDBw4EXCSQ9JRq8DOWZBWW/zkNUfqW9iu9S1Lkk08+CaSOrJPK8JI+r5K63/3udwEXTzxixAigS79UBJMkg6T3V7/6VcDlQstCLp+lihnoGj799NPB2KRXV0psT3MPdR2kF+63335AqXfBZ5111uHZZ58tu432odVGGrTKkbRLYs2O0ke18lFsgKzWtSC7h2KzdR/0LOkzSQnetH7m3JfZQrWgzjvvvJr3peWOLkhWxdf1Imiy0JIp7JoSfqEEvYiqNKKXbKeddgLg9ttvD/ahpbmWajLIyAi4zz77AC5IX8tbGU8Uttq/f/+SetwySr377rupz99HBjp9TpkyBXDBITL+KYlCVHqRwbkd417mDTfcEIie9PUSpyEcoqtJSgkcMs5K4OiexqVpRqGX1n+J9ZzoM81LnHbZbctsw2gS6iaZFXiuT0lTJXorAR1KlyaScvq7JJRcNVkl3PthdL5EDh9H0lvnoSSAgw46CHDL6kcffRSAPfbYA+hKd5Rk1jLv8MMPB7rSP8EZZFTRUxJc0lbXY/bs2cG+NA6pHFmi6zFhwgQAVlhhBcBJMH0fduFVQtdy8803B+Cpp54q+q2S98uNp5r7/sUXXwT3WSuiLbbYAnDprFpdXX311UVjkWGyvb09WFGcf/75gFu9aJUyZswYoNS9qGsULhvkU+3zbJLZMJqEbledc+zYsRxxxBFlt1Fghlw0Qr9TGF4SosI5fbeOZtOFCxcGktAv1yMDmPSwa6+9FnA6khIvDjzwwGAbpcNp9pa+JXeTfqvZXm4+GWruuOOOkuJ+/r/TGsAWLlwY2A6kE0t6jhs3Dqhso+jRo0fgqlNo5I477hiMWccB59JTSqDcgVqVDRo0qGzqISQzgEW57OSCVEptmr5YcpP++9//BuA3v/kN4Owcupevvvoq4K6Z7D1JUlRDAScWNGIYrUQmktkPe8wbzaS+tbGaBIxys3pUq1LNlnHXbddddwXg4YcfBlyYn8Y8c+bMQAqp+J8s0JMnTwZcMTglXMg1pGAHBZm89957gSQ+44wzABeMEHV+UedYDgVLqIDEdtttB8C9996bdBcl6FpKCk6cOBFwxSpuu+02wN3befPmldhQyqV5Vjq/cOfMagNs2tvbg9/oU6sphbYqaaMa/bfautkmmQ2jSeh2OnMSKhUcT7mvkiL48kMqwSN8vLjUTunxksSyZksnlIV00qRJgaRV8Id80AqbPPPMMwFXZF5WbYVP6u8PPPBAyWrI12dr6WghS6usvtIxpRcmwS+OqOsl/7gK240cORJw0jdcMjivXlO1WMX9hArtQ00PFDySBSaZDaPFqJufOUuyTCYIo9k1XMAvTP/+/Ut6H2l2l7VWCSQXX3wx4KyaSons379/EC12+umnAy75RL5J9a9ScsKll14KOB1e+nhHR0eJJM7C5659HH/88YCzQKttkJCk9svORu1Lerai3GSRl0SWn1YrHCVt/OIXv6jhTMpT7bXaZZddAt1eyEqdxiKeNSaZDaNJqJvOLD9snNRLg3yRKqonpOOlaVMTVZzAvyZRupX/Nz8KShZnnbd0587OzuAaaBulRE6aNAlwlmmtAvyWM+FItbgSR3FB+tXolJVWQMOHDwec73WjjTYK/qbul7IhqBStUkW1b9knJO3TrLpqLRukY/qrLr+go1Zde+65Z7CNPAzyp/tNCbLAdGbDaDFy05k1q6kI2nXXXRe5XZqC5nvttRdQKpH123CrzWqIW6WEpZ2klV/AQNtodaAZevTo0YArVvDhhx8GzcSkZyvW3C8bJOkkK/fjjz8ejAO6LL/S0eKsq0kJ2yH83smVkH+80t/ArVwkBWUP0Lknkci1lOmNioWO6gEdPo5sF+H8Af1GdoU8JHJaTDIbRpNQN53Z1+VUisfPx21rawvyeRXfHBdZFo4SqmFcJTpzRAQOoW2KvotDxe2kXykvd8sttwx0Yp2XspBUUka/VUZZEmmrffltXytFgGmV4+ckh9HxyzWGi0OtWU888UTAXb9y+cppyarUrm93UGSeSkRJuvfq1StYeaikU56YzmwYLUamkrlctI703fvvvx9wubnKiJFUSjiOon/X4ndOMquH9a1qo4YUQ71w4cKKv5XPUiuOuIyoKDQ++Wvfe++9zErtqmqK9FuVM5Iv+M477wS6pL3asSgn2I8/16pKpZ5qycNOI5nDz07Se6jfqBTUrbfeWlOTh7Qklcx1W2aHln1A6bIw4fGrPXws4QvVt2/fApQa0sIvcKXx+hOL7yaLUgm0jYwzCifVOHwXSRRxE1kWdbNVLME3FJWrTe1TS+ikiJvM0k7IaZGBMqqCbBZEJfSEsWW2YbQY3S7RolAo5CKByxwvONhSSy1VAFcD2e9GEE598/sL+ysO/UbSK9zhoNowVD9pAUpLHYlQ0cPMltmikiSpN1kZwISKQCjBRYkxqnE9YcIEZsyYUethYokoW2WS2TBaiYYnWsgNo1mwnlLZx3dFRRmeNthgA8AVoPPxpZXvVgsHZcSFYqpzoNImhb9d7969A4nv6695BjFUkshDhgwJChwuiihE85FHHgGccU6poCr8lxdW0M8wWpyG6cy+RG4U5RItpDPLEtq7d+8gScIvZaOyQH7/Zl+nDoeECl+H1vdx/ZnDCRD6f3XOUAG5UFmbzHXmLJELLWnoaBRZ68xZoE4n06ZNq3lfpjMbRouRSjIbhtF9MclsGE2CvcyG0STYy2wYTYK9zIbRJNjLbBhNgr3MhtEk2MtsGE2CvcyG0STYy2wYTYK9zIbRJPw/9/QWl8YzmloAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with get_session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    run_a_gan(sess, G_train_step, G_loss, D_train_step, D_loss, G_extra_step, D_extra_step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Convolutional GANs\n",
    "In the first part of the notebook, we implemented an almost direct copy of the original GAN network from Ian Goodfellow. However, this network architecture allows no real spatial reasoning. It is unable to reason about things like \"sharp edges\" in general because it lacks any convolutional layers. Thus, in this section, we will implement some of the ideas from [DCGAN](https://arxiv.org/abs/1511.06434), where we use convolutional networks as our discriminators and generators.\n",
    "\n",
    "#### Discriminator\n",
    "We will use a discriminator inspired by the TensorFlow MNIST classification [tutorial](https://www.tensorflow.org/get_started/mnist/pros), which is able to get above 99% accuracy on the MNIST dataset fairly quickly. *Be sure to check the dimensions of x and reshape when needed*, fully connected blocks expect [N,D] Tensors while conv2d blocks expect [N,H,W,C] Tensors. Please use `tf.layers` to define the following architecture:\n",
    "\n",
    "Architecture:\n",
    "* Conv2D: 32 Filters, 5x5, Stride 1, padding 0\n",
    "* Leaky ReLU(alpha=0.01)\n",
    "* Max Pool 2x2, Stride 2\n",
    "* Conv2D: 64 Filters, 5x5, Stride 1, padding 0\n",
    "* Leaky ReLU(alpha=0.01)\n",
    "* Max Pool 2x2, Stride 2\n",
    "* Flatten\n",
    "* Fully Connected with output size 4 x 4 x 64\n",
    "* Leaky ReLU(alpha=0.01)\n",
    "* Fully Connected with output size 1\n",
    "\n",
    "Once again, please use biases for all convolutional and fully connected layers, and use the default parameter initializers. Note that a padding of 0 can be accomplished with the 'VALID' padding option."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct number of parameters in discriminator.\n"
     ]
    }
   ],
   "source": [
    "def discriminator(x):\n",
    "    \"\"\"Compute discriminator score for a batch of input images.\n",
    "    \n",
    "    Inputs:\n",
    "    - x: TensorFlow Tensor of flattened input images, shape [batch_size, 784]\n",
    "    \n",
    "    Returns:\n",
    "    TensorFlow Tensor with shape [batch_size, 1], containing the score \n",
    "    for an image being real for each input image.\n",
    "    \"\"\"\n",
    "    with tf.variable_scope(\"discriminator\"):\n",
    "        # TODO: implement architecture\n",
    "        x=tf.reshape(x,[-1,28,28,1])\n",
    "        x=tf.layers.conv2d(x,32,(5,5),strides=(1,1),padding='valid',use_bias=True)\n",
    "        x=leaky_relu(x,alpha=0.01)\n",
    "        x=tf.layers.max_pooling2d(x,(2,2),strides=(2,2))\n",
    "        x=tf.layers.conv2d(x,64,(5,5),strides=(1,1),padding='valid',use_bias=True)\n",
    "        x=leaky_relu(x,alpha=0.01)\n",
    "        x=tf.layers.max_pooling2d(x,(2,2),strides=(2,2))\n",
    "        x=tf.layers.flatten(x)\n",
    "        x=tf.layers.dense(x,4*4*64,use_bias=True)\n",
    "        x=leaky_relu(x,alpha=0.01)\n",
    "        logits=tf.layers.dense(x,1,use_bias=True)\n",
    "        return logits\n",
    "test_discriminator(1102721)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generator\n",
    "For the generator, we will copy the architecture exactly from the [InfoGAN paper](https://arxiv.org/pdf/1606.03657.pdf). See Appendix C.1 MNIST. Please use `tf.layers` for your implementation. You might find the documentation for [tf.layers.conv2d_transpose](https://www.tensorflow.org/api_docs/python/tf/layers/conv2d_transpose) useful. The architecture is as follows.\n",
    "\n",
    "Architecture:\n",
    "* Fully connected with output size 1024 \n",
    "* `ReLU`\n",
    "* BatchNorm\n",
    "* Fully connected with output size 7 x 7 x 128 \n",
    "* `ReLU`\n",
    "* BatchNorm\n",
    "* Resize into Image Tensor of size 7, 7, 128\n",
    "* Conv2D^T (transpose): 64 filters of 4x4, stride 2\n",
    "* `ReLU`\n",
    "* BatchNorm\n",
    "* Conv2d^T (transpose): 1 filter of 4x4, stride 2\n",
    "* `TanH`\n",
    "\n",
    "Once again, use biases for the fully connected and transpose convolutional layers. Please use the default initializers for your parameters. For padding, choose the 'same' option for transpose convolutions. For Batch Normalization, assume we are always in 'training' mode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct number of parameters in generator.\n"
     ]
    }
   ],
   "source": [
    "def generator(z):\n",
    "    \"\"\"Generate images from a random noise vector.\n",
    "    \n",
    "    Inputs:\n",
    "    - z: TensorFlow Tensor of random noise with shape [batch_size, noise_dim]\n",
    "    \n",
    "    Returns:\n",
    "    TensorFlow Tensor of generated images, with shape [batch_size, 784].\n",
    "    \"\"\"\n",
    "    with tf.variable_scope(\"generator\"):\n",
    "        # TODO: implement architecture\n",
    "        x=tf.layers.dense(z,1024,use_bias=True)\n",
    "        x=leaky_relu(x,alpha=0)\n",
    "        x=tf.layers.batch_normalization(x,training=True)\n",
    "        x=tf.layers.dense(x,7*7*128,use_bias=True)\n",
    "        x=leaky_relu(x,alpha=0)\n",
    "        x=tf.layers.batch_normalization(x,training=True)\n",
    "        x=tf.reshape(x,[-1,7,7,128])\n",
    "        x=tf.layers.conv2d_transpose(x,64,(4,4),strides=(2,2),padding='same')\n",
    "        x=leaky_relu(x,alpha=0)\n",
    "        x=tf.layers.batch_normalization(x,training=True)\n",
    "        x=tf.layers.conv2d_transpose(x,1,(4,4),strides=(2,2),padding='same')\n",
    "        img=tf.tanh(x)\n",
    "        return img\n",
    "test_generator(6595521)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have to recreate our network since we've changed our functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "batch_size = 128\n",
    "# our noise dimension\n",
    "noise_dim = 96\n",
    "\n",
    "# placeholders for images from the training dataset\n",
    "x = tf.placeholder(tf.float32, [None, 784])\n",
    "z = sample_noise(batch_size, noise_dim)\n",
    "# generated images\n",
    "G_sample = generator(z)\n",
    "\n",
    "with tf.variable_scope(\"\") as scope:\n",
    "    #scale images to be -1 to 1\n",
    "    logits_real = discriminator(preprocess_img(x))\n",
    "    # Re-use discriminator weights on new inputs\n",
    "    scope.reuse_variables()\n",
    "    logits_fake = discriminator(G_sample)\n",
    "\n",
    "# Get the list of variables for the discriminator and generator\n",
    "D_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,'discriminator')\n",
    "G_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,'generator') \n",
    "\n",
    "D_solver,G_solver = get_solvers()\n",
    "D_loss, G_loss = gan_loss(logits_real, logits_fake)\n",
    "D_train_step = D_solver.minimize(D_loss, var_list=D_vars)\n",
    "G_train_step = G_solver.minimize(G_loss, var_list=G_vars)\n",
    "D_extra_step = tf.get_collection(tf.GraphKeys.UPDATE_OPS,'discriminator')\n",
    "G_extra_step = tf.get_collection(tf.GraphKeys.UPDATE_OPS,'generator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train and evaluate a DCGAN\n",
    "This is the one part of A3 that significantly benefits from using a GPU. It takes 3 minutes on a GPU for the requested five epochs. Or about 50 minutes on a dual core laptop on CPU (feel free to use 3 epochs if you do it on CPU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 0, D: 1.103, G:0.8712\n",
      "Epoch: 1, D: 1.129, G:0.9757\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPMAAADuCAYAAADsvjF6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnWecFFXaxf8TAMHFHcWAEXPOijkr6opZDKBijpjWLCqrq2tEXNRFf6Y1K66riKiYEXPEiGJGERRBV15RwGHm/TCeutW3q7qrqqu6m557vjT0VFfde6vqnic/da2trTg4OMz7qK/0ABwcHNKBe5kdHGoE7mV2cKgRuJfZwaFG4F5mB4cagXuZHRxqBO5ldnCoEbiX2cGhRuBeZgeHGkFjnIPr6+tbAaotaqyhoQGA+vrcvam5uTl0rHV1dQC0tLTU6bvGxsZWgLlz52YzUAv2eAV7zPq/jtdnS0sLLS0tBc89d+7cOv/3DQ0NOffQvlZ9fX3eObVW9v8bG9sen06dOgHwyy+/BJ4z6Bz23KLAPofm2NzcXOf7LueESZ5VXce+XthaB/02yXU1H51D6zpz5szgxbOvHXMxq+sttqCXWp9z5swp+pvW1lZvoap9fvbDFeXe+ef3xzliz9G/eQR9L0R52H3j0PjiDifvHP4NOc17WMoYk/zW/o02y99//z3Sy+zEbAeHGkEsMbtakcYuXw0oxrzlnmex68VhYhtpzCHrdSiFkTt06AAYlc1Wa4LOHaZeRYVjZgeHGsE8zczS2Tp27AgYHbm5ubliY4qCzp07A7DkkksCcMIJJwDw8MMPA/Dpp58C8NNPPwFmnrIF/Prrr0A0m4CNKOyeRDd3yEUUJi6GuJKPY2YHhxrBPGHNXnbZZQF44YUXAFhiiSU0HgBmzJgBwHLLLQfA//73PyC+tTcLS6jcC//5z38A6NWrlydJhDGgPsXA3377LQCPPvooADfddBMAH3/8cdFx2NbsLN2Lkhw6derE77//DhgpKYvrZWXNtl1TcVxSQpgHQIiyHkHzK4SqFLP1UIwbNw6AtdZaq+DxXbp0AWDxxRcHjHhaCSy88MIAvPzyywCsuOKKQLif1Q/7IfrTn/4EwEorrQRAnz59AHjooYcSjy+Nl0ouExl59LnbbrsBMHjwYBZbbDHAvMzamLp37w7ArFmzSh5HlDVNglVWWQWASy65BDD3QWNvbW3l559/BoxqNHr0aMBsvJqvXuYk6+4MYA4O7RRVJ2avu+66vPnmm4BhaCFMZNEOffHFFwMwaNCgyNdLS8xed911AXjttdcAY5QLuSZg3BZ25E+YkWratGkAbLLJJgB88cUXRceVRtCI77cAzD///AAstdRSAOy0004AXHjhhQD8+c9/Dj3HlClTcn6bJNBEkIQwZ86cVO6h7sPVV18NwIABA4D859AP3aP/+7//A+Dxxx8H4NZbbwXgqaeeyjkuyXjsKL7Q42NfwcHBoSpRNcys3W/GjBmeDqyxLbTQQoAxbIkF33777ZxzrL322gB88MEHka9bKjPrmpImpD8Kch/997//BeCJJ57wDHky3Gk+W2+9NWBcVdLVtDaTJk0CYMsttwRg4sSJRceXZjhn165dAfjLX/4CGEOcmFosW19fnxdPbkNMtsACC0Qeh5hZ66H/p8XM8803H2DWuVu3brHPoTWQTUDPx+effx77XHENYI6ZHRxqBFVjzZa+27lzZ8+t0dTUBBjLoHD22WcDZufSLv/hhx+WZaz+a4ulxBbamWXV7Nu3L2B06aCAljFjxgDw2WefAbDHHnsAsPLKKwOG3d5//33A6M5ZwdbZJW0cf/zxAPztb38DjF1A3gPpwb/99pt3LlmG3333XcC46sTyYsM41m3ZGtK2Zh922GFAOCP7LdO2nUPQ9woMks4sqUusH9FtGmv8jpkdHGoEFWdmWT6lJ86ePdvTIW1GFlPL36qda9999835fzkhi/J3330HtPlYAYYPHw4Y622hsWnHl/4ohhbTiRkfeeQRIJf5soDYRWOWn/uYY44BjBQyatQoAHbffffQc02YMAGAyy+/HMj3NCiYRj7qQsjq/uq5khXbhiSPV155BYCpU6cydepUwEgrshtojGLsHj16AMamss466wDmeUkTjpkdHGoEsZg5zRQ87f6nn35620D+8Bk+8MADXqKBsOCCCwLwww8/AIYZpCtLL4mDtPQtXVvSxPTp04F4IYDbbrstAOeddx4AK6ywAoC3+2sXv/POO2OfuxRIvz3rrLMAvKiul156CSjMyPY4Nt1008C/L7rooiWPMyk0NkkHmq8g3fzaa68FjG1j9uzZnv1CEtgVV1wBwGabbQYYnVnXUGSgJFHHzA4ODqGIxcxpxvWuv/76AOy6664AjB07FmjTncXaG220EQDPP/88kG8xXm211XL+X05oLRSjWwx+6+ciiywCGGv1pZdeChidWTrxPffcA8Att9wCwMyZM9MYelFoPSURbbzxxoBhmREjRhQ9h+Yra/4WW2wReFycaL20IT1XlmYbkvyeffZZwLDpjz/+6MUP6J5orfR829B6yHqfBRwzOzjUCMpmzZZPcr311gOMr1jpjNKH+/Tpw4YbbgjAUUcdBeTHxn711VcATJ48OfF40rKM2hUqFbUlHWnppZcGYNVVVwXaChJst912gMnyUoSbdDR9Sg9P4ldOQ2feYIMNADMnMZWkEbGM4gK0pl27duXkk08GzD2Uf12sr8/x48cnHl+p97AYS+qeSnrQ8/bjjz96TCvJUs9xoThuMFl08runCcfMDg41gsyZWbub9Nt+/foBsMYaawBmJ9tqq60A2G677UKja7QTy3JYCb+yXbBNsbfSCQ844ADAsGpYIYIo2HnnnQGj08maajNh2tDcDjnkEMAw2OzZswHYYYcdAONjle4vtu3SpUto1phdRlYxA2E+3iwh/7EYVz5hQc+uLPEac2NjY+z7qXkrvyALZJ5ooQVQUMCVV14JGNFSJny/W8AWxfRyS8yTSJNG8ETcRAu5FmTE2nPPPQEjbq2++uqAEbNLEXd1b2RkeeONNwAYOHAgAK+++mrob8OC9OPMUS4bqQPaeOVOSpKIYAdVKLxR1WTiNCAotdKIfn/ooYcCcP311wP5lTV1nN2EwD8fGcT0WzvBRBuwSKvQvbNhJ8uEwYnZDg41grKlQGo3VykWGQK0+6kky1dffeWJk0p6lyFGwSSbb745YHa7UhCXmSVBiKXkTtJYJGlIzJaIJubZYostvLn6xgCY3TzMvSEj0rBhwwA45ZRTQsdZCjPLZaN7tN9+++Wc8+CDDwZMddEo0oeCabQ+SnMVevbsCZiwx0KwmdLfnibJM6p7uffeewNw5plnAiZ4R2P1GyglLalskBJpZPBTAQmNVSK9zhmntJVjZgeHdoayMbN2P+maMqZI79U4WlpaPJ1NgfxyVSlpYfnllwfKz8x1dXWhVRejrmOHDh28YBixuhIqdtllF8CkVdpMrWtqXfbaa6/Q62q9/az1xxxi30MZhvT54IMPAiZBQezzySefAG3sqjBHVRT1u63AFGYQ3nvvPcAkIhSCXV7JX1YnjWdUxR9OPfVUwCSaPPnkk0BbgJOSLtQsT/fyqquuAow0Iyh5RjaVOM+uY2YHh3aGzF1Ttj6l4JAwq2V9fb3HxAow8elGOf8vN1pbW/OssT52iHSOuXPnegED2p3lxpFlV8wti7hg1+JubGzM2+FtfTINfP3114BZf7GMUlSVAHL77bcDhcNr5ZGwIVel3Z3Ej6x7bekequyU9GDp+2LmMWPGeMUUtM4KrNlmm21yzqm1ULhylt1WHDM7ONQIMmNm7VjSq7STFSsPs+iii3qB/NqltRMr0T0NJPX/2qV09CmWCmMNhXOussoqfP/994ApA6TSOvvvvz9gLP9hVm3ZFBobG/M6RpTS2ygMOpcCZPQpSSJOaqZgxxDoU11Jgu61LRUVC52MC51X3gZZ2JXmqsYG/mdYNgAlxcgmJOi5UHxFnPsSV7pyzOzgUCPIjJnlm+vfvz9g/GtK9FY6mV1YfdiwYXlJ4rIYKng/DSt2UmhssroqAkyWdrGtdmgV51Npo+nTp3u613PPPQfAaaedBpiwyGJ+ZummhSLgskgLFcvIQq0CeEn0QP3GDneVZb+QFBYUiZUGxJpaV1msFQnnT3fVeBULoaIEdn8qxQTIzpAlHDM7ONQIMvMzS+9QYQExs2Cn+9nNyMDslCogf+CBBwLpJBoEtf6IMj/NQ+1HFOmjcRfTxVtbW73xa87FGEbz/Pvf/w7AP/7xD6CwhFJKBFgYpKvLIl0K+4vlFREmKEJQaYdBXgLpylq/WbNmpdoFUoUGlKr69NNPA8Y33tDQ4Pnc1YjBLuavCC/FRCRJsHBF8B0c2iky05lVjO66664DYMiQIW0X/GM3jdKMS0XtxchBvsekSKpviZWk29mtUoqhrq6uYFM5P7SGe+21F2CsqZWCnc2WBHbjAqVX6vtlllkGiFaaOCt/s2w0Wu+ghnX/+te/gHxGlrR00UUXAdmmPNpwzOzgUCPIjJm1e8p6rdhbtby0dSV/m9O7774bgL/+9a9Auows2A3eokIRbCqLq0/5ikvxfWrN3nrrLQC23357IDxqqhCyaEQuxioF8svaNgbdf8V3F2J/W2dOG7K0//jjj4CxuMtDc9lll9GrV6/A38qroSKMpcD5mR0c2inKVtBPVm0VThfrKntKVTSuvfZaL1c0y7JASdleY7r33nuBtqL9YJhG1kv5l3v37g0YP+Piiy/u+dilXz3zzDOAkVqkZ1WihHAhpHE/ZCEWy4kFR48eDRjbShDsclJZPR929RAxsyq8HHfccXmsqXul5yJJWWR7XnHnVzX9mcuNUkvOVCs0L4mg/t7Ff/y9InO0XZV6mW+77TbA1HVTUI5eoBkzZnjuKTtYRMdMmzYt03uo6wwdOhSAY489Nu8YqQdKtJC4XQqca8rBoZ2i4l0gK4UsDETVALGWHRJbacjNplTHsOIO6meloJHbb7/dK35nd6csVyqsxG2VaZo2bRqHH344YNyGr7/+elnGUgiOmR0cagTtTmcWI0sPSjsUsFKwCxco3PDjjz+uCp05KpRwozrr06ZN81jdd89y/v/zzz+X5R5KEujcuXNe+ecsEFb6KQyOmR0cagRVqTNn6XqQC0llXvywdbJydcwI69wR9Xgwu7jCI6V7poGo4/OXUrJTAe1z2GWX7DVXosJ8883nFbiQG0vWbSV+BJ03yr2zde5i89Iaz549OxO3ob0mQc9oIThmdnCoEcTSmR0cHKoXjpkdHGoE7mV2cKgRxDKA1dfXt0K6hiEZFYKMTuVQAfzdAhobG1shv3Kk39hh16W262aHjTmOQUbuJdURU87sN998AxApdl1um19//TXH8qQ52h0Ok445Kux10/h0/7XGcjsVWnN7XP5qMfPNN1/O/IKCU7KYVzHEdAEDJrNw5syZkS4S62XO4uWyH6pK6vB2iZpCVu2woveljN/fogdMCp6azikS6fPPP/eOC7teWLG/sDlmDX+KK5gEmyS/LYSwlzirpJUs1k/njLNG4MRsB4eaQdX4mavRqh7mC/V/J6QxfmUSqSSRCuerGZnSRpVOmeSa9lzizCPNOWfFlLZqZKtx/n9XgzRYCHHzBxwzOzjUCCrOzFkwXFqI2gwOSmNJle9VppCamCvDSMUKXnzxRSBdVosz7jA2jwLlV4cZCsNa5caFfd5C86umZy0NOGZ2cKgRlJ2Z5ZJQ8fi11loLgIceegiAyZMnl3tIsZBm3LZatqoxmV1mViylUjpRyrbarh8baYw7yjl0fbWn3XzzzQFT6E5zkfSh50Bld4KkItuGESQh2MyfpCxvWHkiuQrXXHNNr0ClivnL8pxmy9a4xSHLngKpPkkHH3xwzvfq49O9e/fYJvkkCEovK1d6oK6t2srqNaUkENUGU+XPq6++WmMtem49gDrX7Nmzy5YCKcPdAQcc4NU614Yl4578yPKly4eu71WaR1VdO3bs6CWPqHaa7Wf3xwooFsJGlOdcYzr66KMBOP/884H8zo5+6F4pMeSyyy4DTH+qb7/9NvL17c1D99Au/RQGJ2Y7ONQIysbM2nXUAXGHHXYIPO7nn39mgw02AMyuVqyncxJot//tt9/KysyNjY0cf/zxgOnZa4vE06dPB2DHHXcE4IMPPgCi9diy0/r80VGQ7hzFHKpAqj7NHTt2zBuHLboWM6IpQGbcuHHcddddANxwww1AvoTiZ+Yk81OklSQkMXKUziO2OmBHD+oZVn+w4cOHA6YGeSEjqytO4ODQTlF2nVn1pFVv2u5K0Nzc7BVw026m8qyF+hHHRSFmztJd1qNHD0aOHAm0GVLA7OJiHHV7VLCIjCxRYMcx27t6GvdQaydd/ogjjgCSdwkphkmTJgGmFFJAvHUsZtba6NmThKQSumGMrOuOHTvWKx0snX+hhRbK+W1YsUHZgy6//HIALrjggtDnK6hTacF5RTnIwcGh+lF2ZpZLasyYMYCxIGrXa25u9qyWd9xxB2B0JekfaaDc1myx1uDBg70yrSpeJ3z88ccAbLvttoApTxslxFK7uOaldZ0xY0bJzKxzq0yP7svOO+8MZNfzyYaurz7JQUXio2T2abxiV4XHhpUnlmR08sknA22F+6Vn614dc8wxgLF39OnTB8jvqSZICltyySW9/mX2mDUef9HJQnDM7OBQIyh70Ii60staKcbSrtTY2OgdI2gnThPlCuUTU2qn7tu3r+dz1RhUrrV///5ANEaGNmaSzqZjo1i8o0LMp4QPxQist956QLKOl2K5gw46CICzzjoLgJ49e+YcF6Rzqo/XO++8AwTPMcqaSSI655xzAKPn6rfyY3/00UeAiQd47bXXvLHpno0aNSrnb0pbPeSQQwC4/vrrAcPcgqSDCRMmcPHFFwN4PZ/1bsSVeBwzOzjUCMrOzGrnIV0iqLytdIh3330XSNZRrxiC/JxppsTpXGIxRXN169bN+5tYVDYBMUGxkq9i9nXWWYf1118fMF0UZfmNkyQSBulssr4rISQKpBMqRkDhm/JU6JzqfCnJRWy5+uqr552zb9++gGHmJGhtbfWeOV3TLgssv76iFL/++uuc4xobGz321G/0zNqW9hNOOAGATTfdFDBhqzpXU1MTF1xwAQAjRowA4Msvv0w0N8fMDg41grIxs3YiRQvZ+pZ/d9TOKV1NeqGtO5eSLhfFQlwKQ6uA+XHHHQfAyiuvDLRJIhr3uHHjAONzD0ua13pI19twww0B2HvvvT12F8KKzseBrqOUyziMLOj6//znPwETay2dUpKDPpVsorjoIIghS0XXrl0B81zZY9YYhWL13SD8WZSEIl/8E088ARi/NBhJS9KqXVcuKhwzOzjUCMrGzFtttRUAiy++OBAeZVVfX+9F+kiXUKysIsBkAf/0008BOOOMMwB4+umnc85VCEHMlYauLMuorLV77703kGuZlCVUsczyqysFUtBvllhiCcDokUornD59urfT6xxigihxxUFoaGjwWCRIbw2CrR936NCB5557DjAFF4qtrXRqWX+33HLLvGNkDxCSSh8qkGhLh2JCraUy+WyGTJLV9/bbbwMwcOBAwNhJ/OefMGFC4PWiwjGzg0ONoGzMfMUVVwDhu2nQ99IV7VhaHbv22msD8OCDDwJGL50yZUpawy4Ku0WsIoJkxbT1stbWVm98L730EmAYef/99wdg4403BoyuKh3P9ksPGTLE02sltZRaPGG55Zbj7LPPBor7OcUgY8eOBeDf//430KZrS7+NOg7p/nb5IL+/2W5onrRUk3zAmp8/+hCMxKcc5TSga3zxxRd5f5MtyLZ/xGXosr3MxZIk/A+hxLXx48cDRnzWi6MO9nKdyNh0//33A+aFKpTMHxYIXwxhv5P6oAD6VVZZpeh1tthiC8CMX0ER+pSRJOwcX375pbdW9jGxq1T8sba77bab13VRCKv9ZRuGpP5Mnjw5snFS55TRTYUA9IA3NTV555fapQCMpLXI9ttvv5zf2yGxUhHSrBoi6N76IeNfqXBitoNDjaBszKxgga233jrne+3gStb++OOPuemmmwB47LHHAGOIUNXKQw89FMjvQawkDiUy3HTTTaGiWJJQRP947V1dSQCLLrooUJiR5YqQmKcSMy+88AIA9913X8FzfPLJJ0Cbm0PsaAff2CJbMeh3r7zyirfetmRg16CWC+ett94CjNoQhZW1bgrdFevq+++//x5oWyut07Rp0wLHEwddunTx1l/QfDRvBStlATtsFfDqiZUKx8wODjWCsjHzbbfdBsDpp58OmN1VutH7778PwDXXXMObb74J5AcYKKwzLK1M5xRj19XVFU38LhViB4VtimnC9LmWlhYvWERpoDK0yBYg/duGQgala8sQpvP6kdS90bFjR4+57GIDdjCL7CBiZKX/FWJmnVNSlqSQddZZJ+ecOscnn3zilQ1SAIp/rHHR1NQUVFoJMBVisyhTpedCRk6hpaWFr776Cshf37iSh2NmB4caQdmYWZ0LlUYn/VZuF+krM2fO9ILYtVNph1pxxRVzvrehHVW1mQsxRKkBItrdxTS2u8OGxvLbb795tcHltlKghJJQ7B1Z0ouCOPyMnDaam5s9xgtbZ81dyf0ar/9+2esr95sCUmy7h9ZRHgoFkZx33nk8+uij3tj8SFJGKkiq0/Mmu06a0JrceOONQH5BikmTJnm2IXvN4oYrO2Z2cKgRlI2ZpZeoCJw6GqqcrML3evbs6aULKj1OwRNKErd3N+HZZ58FonXFiGvttSEGXmmllQCT/GCzqt1Z4ffff2e11VYDTNlVFYq3WV1hgwqFlU4aBUkljy222CK0fI4NsamKNMpHPGXKFE/SOvfccwETCCNm1Fxt/VXjVqL+qFGjUu2FrVBNP2SLibO+xSBGHjx4MAD77LNPzvfCwIEDvbWyEXd+jpkdHGoEZS/op51JSfUqiu9PCZNupCRt7ebS0WwG0xzk642iUwa1/ogyP41fup76QCmqKIyZi30H+fPu168fYFIlkzCRvwztH+MveJKDDjrISwCJcG7A2Cr8bGsXvbd/Y0P6r9q7XHLJJUA0q3ycUrtNTU15YZryX+ua1113HZBMetN8VQpIZZHs50JRX5JMC8G+h2FwzOzgUCMoOzML2qnkX1Q8rJ2YEAUqkq+Y7KA52fG3YhF/GdMo87Ot19Lt9H2UeGHpzypupzI4SkZ55plnAKMzJ/EZB5Wh/eP7gnN85ZVXPE9DGOxkjiC9NyyOW1KTmFg+VvlfleYYs2905HvYo0cPL5HC11wPMDqz9FtFthViaD1H6667LmB81WqiZ0N2IBXpiNJqyBXBd3BoZ6gYM9uQzvzyyy97qYzFWE66pKy9iu/2Q7ub9G75FH0xzLGYWRZbxe9Kj7ejd8J0xS+//JJrrrkGgEceeQQwccgaW1i2TpIew3Ebx916660cdthhBa+v8YW1o5k7d67HwPpU2qckGa2PfKzSW2M+j0Cu9FFsfvX19V6zAXkiBHt+er7EppImNthgA0/XlSQZ9qxKIpEerii/KHBF8B0c2imqhpmFhoYGr0yQ2oHYWUbaxWURl185aC7a3fRpN+r2M1eU+SkKTfqUXYQ+jJFV0O7UU0+NrQPbGVpRChAoiitus/UePXp40Xphlnn7uvq/2gc9+eSTXsGIb775BjBx9rIkK1ZAzJ2kFE8SZgbTsE/3sFiMdzEbgR+yh6jlTa9evYBkxQj1vPulx0JwzOzgUCOoOmb2Q7u3CtgpNllF7CZOnAgUtjaKkbXL2QwQR2euq6vz/MuyoKs4nM22ii0+4IADAJOrnMRXHOazLcTwQS1r/zhHwQHMP//8XtPxAQMG5FxHayk2HTp0KGDijnUfGhsb88oYhc3JRpyyR0F2gTjPqCQ7FZ9XZpNsAYVi1DU+WcCVgy9ftS0BJkFca3ZVv8w27IdaIo09B//iS1S0f6vvZ86cGfog2OJtY2OjZ0jTS63zSqyKUmM5KsLEayHoGpqXxP8ff/yx4MtsP6idO3f2yhhpfbURysCYxoNqI05PbB2re1HoHka5ZtjzoyAkGQR33XVXoC0p6KSTTgKMYS+NDiI2gjqVFoITsx0cagTzFDMXg129c+7cuaG7r0Qpv9nf7u1rs3ljY6MnvoqlkhizonQqDEIUttL45EKbOHFiJGbW58ILL+wlfsh4peCWNNgnjIGjdBGxA398Rs3IzNypUye6desGGFaNej+0tvX19d6aZNlN1BnAHBzaKcreBTJLyNnv3/3Dds4glvEZHHJ+K92xpaUlkQvFjyjMYxfOK6Qr27XFVezBn7gSdI2wc/7yyy9eMQS702EcFKuPnjBpJGc8ce6FrutP74w6lix6X0eB6zXl4NBOEYuZ0+xfHHZuf/qcmDZ2knaA28PWg2WxDfqdzUSldFQMQtj5xMhiD83fXoegtZJ+JQtvWEhosbnMnj07z1Zgl/EVivWR9iPME2H/ppBnwv5bUBGFQh0xoI1dJXnI9WQzbtA6g7Gz1NfXe+sr9gy7nu1xifMsF+soYsMxs4NDjSCWNdvBwaF64ZjZwaFG4F5mB4caQSwNu2PHjq1gDAYyEMgwMHfu3NAQy6goFAdrBzjYfZ/s4/2wjTgyfviDRhoaGlr9560W2IYY/1zCDEY6xs6aWmihhVqBvIqQpbaCLQeCwmshd44dOnRoBWOYipJpViwX3UZjY2Oem6yU9Stm/LOrxYSeJ2bCe06EVLHBVDNKDdKvBAptdGHH2g9C2D2cFxEUu2zPL4tns7Gx0SMDRYJlCVfQz8GhnSGWmB22u1XbLi/W7dixo6cS2NE01TbmJCg0h3nlXpWCSqlDnTp18pr3KR03C8RtbuiY2cGhRlBTsdk25syZE7p7VyNDFctfdmhDIQNV1Ci1JNeTjr7nnnt6LZOyZGbX0tXBoZ2iqplZrgeV3lFhP7X4VAE5G9XmWgqD3XhcbU8XXXRRAKZOnQrgFW1XTLHawWRR3WJeQFQXUlpQxZEJEyYAbeWFlC+eJeJKFVX5MisJ/KWXXgJMtwA9xDJq3XbbbcA6tSDkAAAWm0lEQVS8IY5qY9pkk028elGqOaUSP3ZgvXzBqjM1aNAgAK/yZXuD/fJm/TLr/KrrpU0WYL311gNgzJgxmV3f9Wd2cGinqEpmVnqiOlvIRC+DwEcffQSUxshZ7+oaqwwk2223XdHr2vOxmVsSSxTxulwiaDlhGwjjum7iXmf77bcH4Jhjjsk7Rqrfyy+/DJhCDmnC9Wd2cGinqEpm3mOPPQCTaC8ohK5Pnz4AvPrqq+UdWAyoo6N29yBo51WHDtUBV2dMGcikO7399ts5vyuESjCz7teUKVM8o1EYNKco7hfbNSTJLawAQ6lQ0YO7774byI/r//bbbz2J69BDDwVMLXHZeVQMMc69CivcEBWOmR0cagRVx8wNDQ1ejyl719bOlYV+khbUi+rII48E8nfmWbNm8cADDwAwePBgwPQoVucOdR0UdA5Z86sFkpTUxbKpqSnyb207SBw3W9YuOQWEqOSwoOL/w4YN8+w2J554ItDWGdKPkSNHAjBq1Cigre81BPec0v21vRlxpSvHzA4ONYKqY+ZOnTp5wRN2cIB0pIcffrjk66StU0q/PfvsswET4PHMM88AphfR2LFjvR1eEDudeeaZQP4Obe/cUcI9s/S9L7XUUoBhGXs8s2bN8uwA8s3KZ64SwJqLeiSrZ3IQfB07AdOAIKw/dCFEaUKw7bbbAvmll2WjGTp0qJf62Lt3b8B4WBRMsssuuwBw4IEH5pxb66A1nDlzZk7TBkh+7xwzOzjUCKqOmbt06eJZRW32VGfBL7/8suTrpM1c3bt3B2C55ZYDTGTQGWecAZj+xM3NzR4ryW/87LPPAtCzZ8/Ac4uJ4lhIs4R0fN0fFaPfZJNNAHj33Xe9Mdplgy+++GLASDD9+vUDTHRbIdhW3kLdP8NQaO00VnsstkToL76vZ1IeGM1r+eWXB8w91VrJrnDllVcCcPzxx4dWKXGJFg4O7RRVx8yzZs0K9bOJEaopwUAW3cMPPxwwPmPFT8v/qF7THTp04Pzzzwdgn332AUx7WBvaqTXvOO1YsmBv6YV2+5xCfl+NWcwkK78wduzY1MeZFJIsbCv2Tz/9BMDw4cOBYD/wu+++CxgdWfq2pEjpyMKxxx4LwMCBA71e3jaCivwXgmNmB4caQdUxs78NqyAGeO655wCjf5aCUq3ZYqcBAwYAhnFkvZZVc6211gJgww03BKB///5eFlix9iMao1qQZhWLXAw9evQAYNVVV835XhJDlEgsSTA26ym2uRogXdl+Nt544w0Afvjhh6Ln8DcZBFhttdUAY8W22/Rss802jBgxIvBccZsUOmZ2cKgRVB0zL7TQQnn+Q+1y119/PVCaPugv9lcKVFCgf//+gNEbpc/vtNNOgIkQWnbZZYE2a70d61tMSlCcs3SockfASb8TNO6111478jnCLPWyBidBWnYB3Q9JIDZkD0kCze+7774DYIkllsj5++TJk0N/Gzf2vOpe5ssuuyxPnNSCqOJGKSg1mF2isVwRegBUBeWggw7KOc4OogfzEEqM0rFhwSKff/45UNqDXwpU2eWss84C4P777weMy6wQNG9txIKCakp5IaMUtI8CPW+2CmA3TEgCbe5TpkwB8l/m3r178/rrryc+vx9OzHZwqBFUHTMHpQxOmjQJSMclVWp9MAW0qGyMAj+kGhQTmVtaWrxwThmQJILLfWWHEcrtUSmXnNL6FAhzzTXXRP7tqaeeChhDkCB2LwVxOnwUgphXRSDs80cxfIVB99J2TQlHHnkkQ4YMAfJbBsW+Vkm/dnBwqBrEYuYs6znLgOQvmiYo3DENlFpqSLu3KmfK4d+1a1fA7MTSfyUJyJjxzjvveIEkcvVo7jbT6LcKDbQZu1zQmu24446AMciprJHmo3GOHDnSC28V69mhiWm4pNJ6DjfeeGMgvAFhkiIIOtdRRx0FmLWyz/3DDz+EBoe4cE4Hh3aKqtGZt956ayB3d5QL5tZbby3LGIq11qyrq/P03RtuuAEwYZuqqRzWFdCvU6tPkYoUhDGCWF9WbwWiqBhAuRMuxFCyRGsNDjnkECA3qEUpjUpxFDTmNCy4aaWx3nzzzYHfx5GAxKKyqWy++eYAnHvuuUD+s6Xn6PDDDw/VyeNKYI6ZHRxqBLH6M2fRv1g7lnZHv4NeupgYKW54W5Tr+vsXR5mfrcfYTbfD4PdlKjxQRRhsyH97zz33AHDjjTcC8MEHHwBGYil074L6T0O691BruPTSSwMmAKKlpcVbJ0kqsiFobrIxxIEdbKNr/P7774l6bOt8siLLdiHonu61116ACXx59NFHvaQT/Wb99dcHTLGCXr16ASYOwY6dkLR51FFHFZWwXH9mB4d2hoozs50qtswyy3g71ZZbbgkYP2cW8O969fX1rX98F3q8xisdWHpkMf1GFsszzzyTCy+8EMjX+cRish+otG4S33g5mDkK7LVUmuFrr70W+Ryai9ZQa6178MsvvyRiZkXtqcSxHQEmKPJO1506daoXnqk4A0mP8sZorPb8lU6pSLAo0qZjZgeHdoaKW7O1O6rQGxi2K3eR+yhSilhSu7TYVSxhn0N+6aFDhwKw77775jGybAOSRBTxlQRBseCVQFh6ZxIrdtgax/XD2ufTZ7HyQ2LZN998E4Bx48Z5xe/lRy+23ir5pPTXNO0/gmNmB4caQcUjwGT1E0OD2SmrqTyQDZuZpdfJz6iiBGo6tueeewJtO7nWT1Fkakcj/3Ec2Cyjc1eqkIEgC7AgiSbJsyMGlhVfn6XG2aupgCRAZcKFrZ0i3w488MCijCw9WyWiFM+epAhhVDhmdnCoEVRMZ9aOprhY/254+eWXV2RMcWCXR9V8lPmklp9qcucvH6zILmUSycKZJoqVJMoadtReUkaqq6vzbCh6Rux497iwYwMOO+wwAC97qW/fvoCxVAvyp3fu3DnUE6H7PXr06JxrlQOOmR0cagQV277tdqZ+KGZ5XoK923/77bdAvv41Y8YML2c7DUa2d367ikmloLkpQqoUZg7Tt5Oynm1fUASYMpxOO+00AM455xzAsK1sHKuuuqpXVFLH6JktVY8vBbGCRqIEVcTFKqusAsB7770HtJn/lYiQpYiSNJzThowzemklZusBkMqgMMaddtqpYF+ltBA0vz++L4vc99ZbbwEmzFEvc9wSPIV6Q8lVNWfOnFj3MMtU3jQRdg/D4MRsB4caQSxmbmhoaIVsRAkZwn7++WcvYF+pdlnspEHhjmmwlgIMZNxSR8Enn3wSgPHjx5eFESrNzNOnTwdMMNBTTz0FmAIHSWA/B5KKmpubEzGzjWplahfO6eDQzlA1zCzXzeDBg72SMkoBFNLcOdPSmYudv1K7fSUTLXbYYQevPO9+++0HpNNTOwx+5io2Pz8r2ymVxZ7rQgUEs7zfjpkdHNoZYjFzhw4dWiG8w3t9fX1i1vYH0ysYoFjHhySuCp1LQRV+S6is9cWuU83Q/BTw8Ouvv5admevr6/OaDZTafCDsOpArfTQ2NuZ4XGzG9FvHwwooCnYih65XX1/vWeVV/icqu8eBs2Y7OLRTxGJmBweH6oVjZgeHGoF7mR0cagSxYrOzCOesFIKMJ2HzK7ebKY3rKXhl1qxZOcaT+eabrxVMeKWd/ZUEdk633xAadt4wg1jQ9/7zBl3PP8dOnTrlzE+Yl55Ze77+6qOFUPGCfpVGHB/lvAjbR5lkQy62uYQVOfT/JuwcUTwSdrKKXYDBHwFW64RT8PhMR+Pg4FA2VLygX6VQ6YJ3lUISxooqKqucT9LrBJ27oaEh716FxTmkcd15GY6ZHRxqBI6ZfbDL0tjHlnvX13h8bVhKPmeac0mrWEChc7e2tubdl/bCvnHn6ZjZwaFGME8ws92eRLpZklK8hXTlsJ2wXEzQrVs3wFTpUC6wCuirbGt7wty5c9sdIwtx51s1L7NesqamJq8T5EUXXQSY9EhBRQvUk+nDDz8E4omhQbWRK/2wqNezukMqiP+dd96p2JiSoKGhgaWWWgqA/v37A3DiiScCeD2adt55Z8B0jiyESt+XQtBzpDrpqvSp4gyql61nNsu5ODHbwaFGUHFmVvXGiy++GIABAwYUrfms/k0jRowAzK6vhPigNDS/q8P/WQ3YcMMNAdh0002B/LGqXnMaKCWZXr9RZwex0tprrw3AtddeC8Aaa6wRqs6oW+Lnn38OtBUyANPHqdJVRQtB891hhx247bbbANP10S50IBVQ/ZnV2SSOahjXfeqY2cGhRlCxcM6mpiYA3n//fQBPxwqCHT9suyrUx1j1qNVVsVBooNh/9uzZFQvn1M6rDheSODRulelVbeYksMM5w+YYxNQyOKr0saSnFVdcETAGuyQBOLrOiy++CMCuu+4KmJLEQpRk/6xCciUZqTuJbDg9evTIm7Mt8ehT/cMkXcWx67jiBA4O7RRl15kVjC+doxAjq3+PmFauGjt75o033gDyS7gUQqW7JILZ8cXIgtjoggsuyHwMWkOVwWltbfX+vcQSSwDGJbbBBhsA5h6GYe7cuXz11VeAscTLQr/GGmsAxkMhfXujjTYC4IUXXvDOAYWZOauQXM3/3HPPBeDMM88Ecvt3qZGB+k1vsskmAKy88so551JThCTlhJzO7ODQTlE2Zpb+Ibbp3bt34HGtra1enyaxt3Rhm8Eee+wxAE466SQgmqXQtjZWApqH3SlROPvss4HSLLvFdnXbYq51aW5u9lIYZXEePnw4AKuvvjpgdGWtof4u3X7KlCl5OqQksMcffxwwbYkkIS277LIAfPHFF4Dx086YMaPseeTyiiiOQd+r5/L48ePZfffdASMNHnvssQBceeWVOed86aWXgPQDnILgmNnBoUaQOTNr5z3++OOBYP0DjJVvypQp3HHHHUB+qxfh+eefB4zOmaRPbyX9zNqt7f6/mscNN9xQ8jWK7ep2adhCa3jTTTcB8PXXXwNtze8ArrrqKgAmTpyY9xu7YMEzzzwDwPLLL58zvi5dugBG+hIrppFUEhUa61133ZUzFkFSgiTAESNGMGvWLMA8o6eccgqQv+7jxo2LPR7bjhEVjpkdHGoEmfuZu3fvDhjrn6KHBPkVb775ZgBGjRrlWQSlXy+44IIAvPLKK4DRt22fZBwkbQdaKrp3784333wD5Esnai6nuOU06nKl2ThOsQH6VJy1dHsx3AILLMDBBx8MGD1az4GguSmufssttwRMr+QoRfNLbTGkZ0C2ATvSTnqufOBPPPFEztjBNMIbPXp04Lhlrdc8o8BmZruOWxgcMzs41Agy15m32WYbIN8Srd3thx9+yPn+tNNOY7PNNgMMi+tYWTrlf06CLNqkxMHtt98eGns+YMAAoHqzhMS8YtkDDzwQgKOPPhowccodO3YM9eNrbpJONt98c8BkFQnlKOukyLaw2PepU6cChlX9Y1p44YUBuPfee/P+BuYZ/eSTT2KPS2sU127gmNnBoUaQOTPbfjaxknYdWVGPPPJIoC1ixt7l9P8ll1wSCC/vEwWVYj3NW75LP8QA0t2qDVp/RW2JkZWrbEtdhSD9Wnm+iu6zrxVFV07qkdDv5S+3feJ2wcBBgwYBRoddYIEFPF1Y9gMbkjxKscpXXXECGUk+/fRTwATpC8stt1zbQAqkPWpSiy++OGDcAUlcUkISMc7fQTAuZNzS2ME8sHK9Vat4batEChKRYUgvuV6uurq60PXVyyw3UCl1xIqlyoZB15C7TEFKiy22WM5xetkPOeQQIKeOdV5ChX1upYOWE07MdnCoEZQtBVLiyNNPPw0YNrJLAkF+kL0+ZUzYZ599APjss8+SDqdkt0ZUKChC4qTfMDRw4EAALr300rQvm4lryobEThkqxbqLLLIIt9xyCwBbbbVVznhUv01GtJ9++in2dSUBaC2TuhftwBUZ43bZZRfAuJV079577z2gTRXs06cPkG88k1it4JhJkyZFHU4o7DTWMDhmdnCoEZSNmbWL9uvXDzBhnQrAl2ti4sSJXkL3+uuvD5idU98rJU+O+lJ056x7TSlFrmfPnt53mqvYSQH8aaIczFwIYmvp2QrQEHPJaKawyDiwU2D9vabKMb+mpiYmTJgAGHecICZeaaWVgGTzs+GY2cGhnaFsKZDSe++55x7ABNRL7/IXQFtzzTUBkxanED8ds+222wImRFRuAOlj1WAVVuE6JfT7IbdMFoxcLQibm4IpSklBtV1J5cbBBx/sBY0Ier5V47wShQkdMzs41AjKXjZIO5j0Rv1fu+ysWbM85lWZUlkvlQguS7gshtLL/F0IiyHrskFKz7SvM2fOHIYMGZLptasBw4YNA/JLDKnofRrJ+uUu/SQpctCgQXnXlvR43333AelIh3GDYhwzOzjUCMrOzGG7qb/HrxjZLrauTxWas5P7qwkqK2Pj+++/Lyl1MyqK9VS2yxbb5YxLQX19vRcLYI9HNpM00jvLbRtRam7Xrl297zQGWbGnTZtW8nU0v7iSh2NmB4caQebMLLlffkXFV0vHkO9YzLz88st7ierSt7RT6RyKulEZ0yRW7Kx2dc1XaZyCdMRBgwaVtSROMRRi5LC44zDo+K233jov+UJzVlnkJOxqH1vuNFZFfQXF16twRpr3Nu78HDM7ONQIMmNmyfvyGauMzAorrADAmDFjAFOKRRkw5513nneMnZmiT+mc48ePB0qLAEsbivRS1Jqgone333572cdUCDbbNTY2ejqhJB59iins2GhBpXiHDx+ep4srrn7s2LE55yplzOWyZuu5O+KII/L+JkZWmmQpVvpSC2c4ZnZwqBGkzsy25Vm76DrrrAOYNh5qY3r66acDJmJmySWX9HQSW2eTPqJdUOVcqqnUrsrICJq/JJRqiE4Lgr9dq1rkfvDBB4Bp7qbsIXkRFH+stqxirm7dunnzFKufdtppQLqRUeWKANN1FNUHhj1ffvllwDT/S4KwZyLus+KY2cGhRpBZ1pR2MzVTf+qppwCTCVWs+RiYnUnRYvvuuy8Azz77LFBafK+vakSqGTeKSRZ7ic3ilNZJE1FbukpS6dWrl5eLrIwgsaskI81Jf5e9w6/zKVpvv/32A0yllTQlE40566wpPSvKgPI/uyr1tPHGGwOmYH4aiNvSNfMUSA1IvYVUcmattdbK+XsQ5LZSHWklh6fhksjqQVCd6N122w0wSSHlDryPmgKpB1Vuvg4dOnhutfvvvx/ILyCh9bcNUP4ACqlCd955J5B84/U/H/azqvDKrHts272W/eK2Nji5rUaOHJnadYMIp+DxqV3ZwcGhoihbcQJBu41cNyonpP9PmTLFM2hlmSKYFTNLvLbdOeVG2K5eX1/fCoZtJDLaBiswYbOnnnoqYCqtfvTRR4DpyaREfaWkTp48OfG87XGBMXAGudH+GHNZihPoWV1xxRU9Jla/LYnXUecdJWjGMbODQztF2Zm5WuCr3+3teg0NDa1QOTZNE0GSBxhmtlHoObBZJK0ghyCIjXR/mpubQ0NOszJiFkMhPT5NOGZ2cGinSD1oJGzXtoNJ9H1QKl6WzFio960d6BJFr4m6MwdZ7bPY1cXI/mQAP8LWP2h8duG8INaE/OSCKPMK61oSdg/8/9bfgorgl9LtJCqyDvzRPOMW+XfM7OBQI4ilMzs4OFQvHDM7ONQI3Mvs4FAjcC+zg0ONwL3MDg41AvcyOzjUCNzL7OBQI3Avs4NDjcC9zA4ONQL3Mjs41Ajcy+zgUCP4f3KeCm7dwC6zAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 2, D: 1.042, G:0.9597\n",
      "Epoch: 3, D: 0.9881, G:1.023\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 4, D: 1.094, G:0.8515\n",
      "Final images\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with get_session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    run_a_gan(sess,G_train_step,G_loss,D_train_step,D_loss,G_extra_step,D_extra_step,num_epoch=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## INLINE QUESTION 1\n",
    "\n",
    "We will look at an example to see why alternating minimization of the same objective (like in a GAN) can be tricky business.\n",
    "\n",
    "Consider $f(x,y)=xy$. What does $\\min_x\\max_y f(x,y)$ evaluate to? (Hint: minmax tries to minimize the maximum value achievable.)\n",
    "\n",
    "Now try to evaluate this function numerically for 6 steps, starting at the point $(1,1)$, \n",
    "by using alternating gradient (first updating y, then updating x) with step size $1$. \n",
    "You'll find that writing out the update step in terms of $x_t,y_t,x_{t+1},y_{t+1}$ will be useful.\n",
    "\n",
    "Record the six pairs of explicit values for $(x_t,y_t)$ in the table below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your answer:\n",
    " \n",
    " $y_0$ | $y_1$ | $y_2$ | $y_3$ | $y_4$ | $y_5$ | $y_6$ \n",
    " ----- | ----- | ----- | ----- | ----- | ----- | ----- \n",
    "   1   |       |       |       |       |       |       \n",
    " $x_0$ | $x_1$ | $x_2$ | $x_3$ | $x_4$ | $x_5$ | $x_6$ \n",
    "   1   |       |       |       |       |       |       \n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## INLINE QUESTION 2\n",
    "Using this method, will we ever reach the optimal value? Why or why not?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## INLINE QUESTION 3\n",
    "If the generator loss decreases during training while the discriminator loss stays at a constant high value from the start, is this a good sign? Why or why not? A qualitative answer is sufficient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your answer:"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
